Line data    Source code

       1            0 : /**
       2              : 
       3              : @file Calculator.java
       4              : @brief This file serves as a demonstration file for the Calculator class.
       5              : @details This file contains the implementation of the Calculator class, which provides various mathematical operations.
       6              : */
       7              : 
       8              : /**
       9              : 
      10            1 : @package com.ucoruh.calculator
      11              : @brief The com.ucoruh.calculator package contains all the classes and files related to the Calculator App.
      12              : */
      13              : package com.ucoruh.calculator;
      14              : 
      15              : import org.slf4j.LoggerFactory;
      16              : 
      17              : import ch.qos.logback.classic.Logger;
      18              : /**
      19              : 
      20              : @class Calculator
      21              : @brief This class represents a Calculator that performs mathematical operations.
      22              : @details The Calculator class provides methods to perform mathematical operations such as addition, subtraction, multiplication, and division. It also supports logging functionality using the logger object.
      23              : @author ugur.coruh
      24              : */
      25            1 : public class Calculator {
      26              : 
      27              :   /**
      28              :    * @brief Logger for the Calculator class.
      29              :    */
      30            1 :   private static final Logger logger = (Logger) LoggerFactory.getLogger(Calculator.class);
      31              : 
      32              :   /**
      33              :    * @brief Calculates the sum of two integers.
      34              :    *
      35              :    * @details This function takes two integer values, `a` and `b`, and returns their sum. It also logs a message using the logger object.
      36              :    *
      37              :    * @param a The first integer value.
      38              :    * @param b The second integer value.
      39              :    * @return The sum of `a` and `b`.
      40              :    */
      41            1 :   public int add(int a, int b) {
      42              :     logger.info("add({}, {})", a, b);
      43              :     return a + b;
      44              :   }
      45              : 
      46              :   /**
      47              :    * @brief Calculates the difference between two integers.
      48              :    *
      49              :    * @param a The value to subtract from.
      50              :    * @param b The value to subtract.
      51              :    * @return The result of `a` minus `b`.
      52              :    */
      53            1 :   public int subtract(int a, int b) {
      54              :     logger.info("subtract({}, {})", a, b);
      55              :     return a - b;
      56              :   }
      57              : 
      58              :   /**
      59              :    * @brief Calculates the product of two integers.
      60              :    *
      61              :    * @param a The first integer value.
      62              :    * @param b The second integer value.
      63              :    * @return The product of `a` and `b`.
      64              :    */
      65            1 :   public int multiply(int a, int b) {
      66              :     logger.info("multiply({}, {})", a, b);
      67              :     return a * b;
      68              :   }
      69              : 
      70              :   /**
      71              :    * @brief Divides one integer by another.
      72              :    *
      73              :    * @details Division is performed as floating point division so that, for
      74              :    *          example, dividing 1 by 3 does not silently truncate to 0.
      75              :    *
      76              :    * @param a The dividend.
      77              :    * @param b The divisor.
      78              :    * @return The result of `a` divided by `b`.
      79              :    * @throws ArithmeticException if `b` is zero.
      80              :    */
      81            1 :   public double divide(int a, int b) {
      82              :     logger.info("divide({}, {})", a, b);
      83              : 
      84              :     if (b == 0) {
      85              :       logger.error("divide by zero requested for dividend {}", a);
      86              :       throw new ArithmeticException("Division by zero");
      87              :     }
      88              : 
      89              :     return (double) a / (double) b;
      90              :   }
      91              : }