feat(proxy): add interface and proxy to handle input

CMakeLists.txt

@@ -14,6 +14,8 @@ set(CMAKE_CXX_STANDARD 17)
 set(SRC
         src/Calculator/Calculator.cpp
         src/Error/Error.cpp
+        src/OperationsPriorities/OperationsPriorities.cpp
+        src/OperationsPriorities/ProxyOperationsPriorities.cpp
 )
 
 set(TEST_SRC
@@ -28,6 +30,9 @@ set_target_properties(${NAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${PROJECT_SOUR
 
 include_directories(src/Calculator)
 include_directories(src/Error)
+include_directories(src/Interface)
+include_directories(src/OperationsPriorities)
+include_directories(src/InfiniteNumbers)
 
 add_compile_options(-fPIC)
 

main.cpp

@@ -4,5 +4,6 @@ int main(int ac, char **ag)
 {
     Calculator::Calculator calculator;
 
-    return calculator.run() ? 0 : 1;
+    calculator.run();
+    return 0;
 }

src/Calculator/Calculator.cpp

@@ -4,11 +4,13 @@
 
 #include <iostream>
 #include "Calculator.h"
+#include "IOperations.hpp"
+#include "ProxyOperationsPriorities.h"
 #include "Error.h"
 
 namespace Calculator {
     Calculator::Calculator() {
-        Calculator::Calculator::description();
+        description();
     }
 
     Calculator::~Calculator() = default;
@@ -17,31 +19,25 @@ namespace Calculator {
         std::cout << "This is the class Calculator" << std::endl;
     }
 
-    bool Calculator::run() {
-        try {
-            Calculator::Calculator::handleInput();
-        } catch (ErrorCalculator::Error &e) {
-            std::cout << e.what() << std::endl;
-            return false;
-        }
-        return true;
-    }
-
-    void Calculator::handleInput() {
+    void Calculator::run() {
         std::string input;
+        std::unique_ptr<Operations::IOperations> operations = std::make_unique<Operations::ProxyOperationsPriorities>();
 
-        Calculator::prompt();
+        prompt();
         while (std::getline(std::cin, input)) {
             if (input.empty()) {
                 std::cout << "Input terminated." << std::endl;
                 break;
             }
             if (!this->_previousResults.count(input)) {
-                // call calcul here
-                this->_previousResults[input] = input;
+                try {
+                    this->_previousResults[input] = operations->makeOperation(input);
+                } catch (ErrorCalculator::Error &e) {
+                    std::cout << e.what() << std::endl;
+                }
             }
             std::cout << this->_previousResults[input] << std::endl << std::endl;;
-            Calculator::prompt();
+            prompt();
         }
     }
 

src/Calculator/Calculator.h

@@ -15,11 +15,10 @@ namespace Calculator {
         public:
             Calculator();
             ~Calculator();
-            bool run();
+            void run();
             static void description();
 
         private:
-            void handleInput();
             static void prompt();
 
             std::map<std::string, std::string> _previousResults;

src/Interface/IOperations.hpp

@@ -0,0 +1,22 @@
+//
+// Created by Pierre-Alexandre Delgado on 28/02/2024.
+//
+
+#ifndef IOPERATIONS_HPP
+#define IOPERATIONS_HPP
+
+#include <string>
+
+namespace Operations {
+
+    class IOperations {
+
+        public:
+            virtual ~IOperations() = default;
+            virtual std::string makeOperation(std::string &operation) = 0;
+
+    };
+
+} // Operations
+
+#endif //IOPERATIONS_HPP

src/OperationsPriorities/OperationsPriorities.cpp

@@ -0,0 +1,13 @@
+//
+// Created by Pierre-Alexandre Delgado on 28/02/2024.
+//
+
+#include "OperationsPriorities.h"
+
+namespace Operations {
+
+    std::string OperationsPriorities::makeOperation(std::string &operation) {
+        return {"1"};
+    }
+
+}

src/OperationsPriorities/OperationsPriorities.h

@@ -0,0 +1,23 @@
+//
+// Created by Pierre-Alexandre Delgado on 28/02/2024.
+//
+
+#ifndef OPERATIONSPRIORITIES_H
+#define OPERATIONSPRIORITIES_H
+
+#include <iostream>
+#include "IOperations.hpp"
+
+namespace Operations {
+
+    class OperationsPriorities : public IOperations {
+
+        public:
+            OperationsPriorities() = default;
+            ~OperationsPriorities() override = default;
+            std::string makeOperation(std::string &operation) override;
+    };
+
+} // Operations
+
+#endif //OPERATIONSPRIORITIES_H

src/OperationsPriorities/ProxyOperationsPriorities.cpp

@@ -0,0 +1,18 @@
+//
+// Created by Pierre-Alexandre Delgado on 28/02/2024.
+//
+
+#include "ProxyOperationsPriorities.h"
+
+namespace Operations {
+
+    ProxyOperationsPriorities::ProxyOperationsPriorities() {
+        this->_operationsPriorities = std::make_unique<OperationsPriorities>();
+    }
+
+    std::string ProxyOperationsPriorities::makeOperation(std::string &operation) {
+        return this->_operationsPriorities->makeOperation(operation);
+    }
+
+
+}

src/OperationsPriorities/ProxyOperationsPriorities.h

@@ -0,0 +1,26 @@
+//
+// Created by Pierre-Alexandre Delgado on 28/02/2024.
+//
+
+#ifndef PROXYOPERATIONSPRIORITIES_H
+#define PROXYOPERATIONSPRIORITIES_H
+
+#include "OperationsPriorities.h"
+
+namespace Operations {
+
+    class ProxyOperationsPriorities : public IOperations {
+
+        public:
+            ProxyOperationsPriorities();
+            std::string makeOperation(std::string &operation) override;
+
+        private:
+            std::unique_ptr<OperationsPriorities> _operationsPriorities;
+    };
+
+} // Operations
+
+
+
+#endif //PROXYOPERATIONSPRIORITIES_H