Added code documentation for client classes

Author: gabrieldiem

client_src/closed_socket_from_server_exception.h

@@ -14,7 +14,15 @@ class ClosedSocketFromServerException: public std::exception {
     std::string final_message;
 
 public:
+    /*
+     *   Exception to be thrown where the socket was unexpectedly closed by the server side.
+     *   It improves std::exception because the information regarding line number and module name
+     *   can be added at call time
+     */
     explicit ClosedSocketFromServerException(const int32_t& line_number, const std::string& module);
 
+    /*
+     *   Returns a message error string containing the exception information
+     */
     const char* what() const noexcept;
 };

client_src/game_protocol_client.cpp

@@ -120,4 +120,4 @@ void GameProtocolClient::send_attack() {
 }
 
 
-const bool GameProtocolClient::is_connection_alive() const { return this->is_skt_closed; }
+const bool GameProtocolClient::is_connection_alive() const { return !this->is_skt_closed; }

client_src/game_protocol_client.h

@@ -24,15 +24,30 @@ class GameProtocolClient {
     bool is_skt_closed;
     GameCommands game_commands;
 
-
+    /*
+     *  Receives all the information from the server to build a valid GameMessage
+     */
     const GameMessage receive_message_from_server();
 
+
+    /*
+     *  Receives from the server code that represents the start of a broadcast message
+     */
     void receive_server_start_broadcast();
 
+    /*
+     *  Receives from the server the amount of enemies alive as a halfword (2 bytes)
+     */
     const uint16_t receive_enemies_alive();
 
+    /*
+     *  Receives from the server the amount of enemies dead as a halfword (2 bytes)
+     */
     const uint16_t receive_enemies_dead();
 
+    /*
+     *  Receives from the server the event code as a byte
+     */
     const uint8_t receive_enemy_event();
 
     const std::string get_enemy_event_message(const uint8_t& enemy_event_code) const;
@@ -59,17 +74,18 @@ class GameProtocolClient {
     GameProtocolClient(GameProtocolClient&&) = default;
     GameProtocolClient& operator=(GameProtocolClient&&) = default;
 
-    /*
-     *  "Plays" the action sequence. Meaning that it converts it to action codes and communicates to
-     *  the server with GameProtocolClient::send_action_sequence and delegates the processing to the
-     *  server, using then GameProtocolClient::receive_processed_actions to get the processed output
-     */
-    std::string play_action_sequence(const std::vector<std::string>& actions);
-
     void send_attack();
 
+
+    /*
+     *  Calls GameProtocolClient::receive_message_from_server a number of times represented by the
+     *  parameter number_of_messages and returns a vector will all the messages built
+     */
     const std::vector<GameMessage> receive_messages_from_server(const uint32_t& number_of_messages);
 
+    /*
+     *   Return true if the socket connection with the ser is still open or false if it's closed
+     */
     const bool is_connection_alive() const;
 };
 

client_src/jazz_jackrabbit_2_game_client.cpp

@@ -82,7 +82,7 @@ const bool JazzJackrabbit2GameClient::is_option_valid(const std::string& option_
 
 const bool JazzJackrabbit2GameClient::should_game_end(const std::string& option_to_validate) const {
     if (this->are_options_equal(option_to_validate, this->USER_OPTION_QUIT) ||
-        this->protocol_client.is_connection_alive()) {
+        !this->protocol_client.is_connection_alive()) {
         return true;
     }
     return false;

client_src/jazz_jackrabbit_2_game_client.h

@@ -35,41 +35,66 @@ class JazzJackrabbit2GameClient {
     // cppcheck-suppress unusedStructMember
     const std::unordered_set<std::string> available_user_options;
 
+
     /*
-     *  Reads from stdin line by line the sequence actions that the user wants to be performed.
-     *  Then it lets the protocol handle the sending to the server of the built sequence with
-     *  GameProtocolClient::play_action_sequence, which also waits for the server to respond with
-     *  the output processed combos
+     *  Compares two options in equal conditions (both are sanitized with
+     * JazzJackrabbit2GameClient::sanitize_string) and returns true if they are equal
      */
-    void read_and_play_action_lines();
-
     const bool are_options_equal(const std::string& option1, const std::string& option2) const;
 
+    /*
+     *  Returns true if option_to_validate is included in the available_user_options
+     */
     const bool is_option_valid(const std::string& option_to_validate) const;
 
+    /*
+     *  Returns true if option_to_validate is the option JazzJackrabbit2GameClient::USER_OPTION_QUIT
+     *  Or if the socket connection from the protocol_client has closed
+     */
     const bool should_game_end(const std::string& option_to_validate) const;
 
+    /*
+     *  Saves in user_input_vectorized the user_input broken into each word one vector element
+     */
     void vectorize_user_input(const std::string& user_input,
-
                               std::vector<std::string>& user_input_vectorized);
 
+    /*
+     *  Calls the appropiate method depending on the desired action
+     */
     void execute_command(const std::vector<std::string>& user_input_vectorized);
 
+    /*
+     *  Returns an uppercase copy of the string
+     */
     const std::string string_to_uppercase(const std::string& string) const;
 
+    /*
+     *  Returns the result of JazzJackrabbit2GameClient::string_to_uppercase
+     */
     const std::string sanitize_string(const std::string& string) const;
 
+    /*
+     *  Uses the client_protocol to send an attack to the server
+     */
     void execute_attack(const std::vector<std::string>& user_input_vectorized);
 
+    /*
+     *  Uses the client_protocol to block the I/O until read all the messages expressed
+     *  by the user
+     */
     void execute_read_from_server(const std::vector<std::string>& user_input_vectorized);
 
+    /*
+     *  Prints to std::out the message read from the server
+     */
     void print_messages_from_server(const std::vector<GameMessage>& messages) const;
 
 public:
     /*
      *  JazzJackrabbit2GameClient is the client side application interface for the game
      * JazzJackrabbit2. It is offered standalone, so everything that the game needs to function is
-     * included when instancing this class. It throws an std::runtime_error if the number of
+     * included when instancing this class. It throws an exception if the number of
      * arguments argv is not EXPECTED_ARGUMENTS. The error exit code can be obtained with
      * JazzJackrabbit2GameClient::get_exit_code_error.
      */
@@ -95,8 +120,7 @@ class JazzJackrabbit2GameClient {
     static const int8_t get_exit_code_error() noexcept;
 
     /*
-     *  Executes JazzJackrabbit2GameClient::read_and_play_action_lines and returns
-     *  JazzJackrabbit2GameClient::EXIT_CODE_OK
+     *  Starts and runs the client game loop
      */
     const int8_t run_game();
 };

common_src/logger.h

@@ -21,6 +21,12 @@ class Logger {
     const std::string LEVEL_ERROR;
     // cppcheck-suppress unusedStructMember
     std::ofstream logfile;
+
+
+    /*
+     *   If set to false in constructor the log calls to this class will not write anything to the
+     * file, nor it will open the file
+     */
     // cppcheck-suppress unusedStructMember
     bool is_activated;