Calc

CMakeLists.txt

@@ -7,8 +7,12 @@ list(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake)
 set(SOURCES project.cc)
 add_library(ProjectLib ${SOURCES})
 
+set(SOURCES polishNotationCalc.cpp)
+add_library(polishCalcLib ${SOURCES})
+
 add_executable(project main.cc run.cc)
 target_link_libraries(project ProjectLib)
+target_link_libraries(project ProjectLib polishCalcLib)
 
 enable_testing()
 add_subdirectory(test)

polishNotationCalc.cpp

@@ -0,0 +1,92 @@
+#include "polishNotationCalc.hpp"
+namespace dev
+{
+    PolishCalc::PolishCalc()
+    {
+        insertFunctionInsideMap();
+    }
+
+    bool PolishCalc::isNumeric(const char num)
+    {
+        double temp = num - '0';
+        if (temp >= 0 && temp <= 9)
+            return true;
+
+        return false;
+    }
+    bool PolishCalc::isOperator(const char num)
+    {
+        if (num == '+' || num == '-' || num == '*' || num == '/')
+            return true;
+        return false;
+    }
+
+    double PolishCalc::calc( const std::string &str)
+    {
+        if (str.size() == 0)
+            throw Exception{"Nothing to work on as Input is empty"};
+        for (int i = 0; i < str.size(); i++)
+        {
+            if (str[i] == ' ')
+                continue;
+            if (isNumeric(str[i]))
+            {
+                pushOperandInStack(str, i);
+
+            }
+            if (isOperator(str[i]))
+            {
+                auto operandVal = getOperandFromStack();
+                double res = 0;
+                res = mOperatorMap[str[i]](operandVal.first, operandVal.second);
+                mCalculatorStack.push(res);
+            }
+        }
+
+        if (mCalculatorStack.size() > 1)
+            throw Exception{"Not a valid string"};
+
+        return mCalculatorStack.top();
+    }
+
+    void PolishCalc::pushOperandInStack(const std::string &str, int& curr_pos)
+    {
+        double operand = 0;
+        std::string temp = "";
+        while (curr_pos < str.size() && !(str[curr_pos] == ' '))
+        {
+            temp = temp + str[curr_pos];
+            curr_pos++;
+        }
+        operand = atof(temp.c_str());
+        mCalculatorStack.push(operand);
+        curr_pos--;
+
+    }
+    std::pair<double, double> PolishCalc::getOperandFromStack()
+    {
+        double secOperand = 0;
+        double firstOperand = 0;
+        if (mCalculatorStack.size() < 2)
+        {
+            throw Exception{"No operand to work on"};
+        }
+        secOperand = mCalculatorStack.top();
+        mCalculatorStack.pop();
+        firstOperand = mCalculatorStack.top();
+        mCalculatorStack.pop();
+        return std::make_pair(firstOperand, secOperand);
+    }
+    void PolishCalc::insertFunctionInsideMap()
+    {
+        mOperatorMap.insert(std::make_pair('+', [](const double a, const double b) { return a + b; }));
+        mOperatorMap.insert(std::make_pair('-', [](const double a, const double b) { return a - b; }));
+        mOperatorMap.insert(std::make_pair('*', [](const double a, const double b) { return a * b; }));
+        mOperatorMap.insert(std::make_pair('/', [](const double a, const double b) { 
+            if(b==0)
+            {
+                throw Exception{"divide by zero"};
+            }
+            return a / b; }));
+    }
+} // namespace dev

polishNotationCalc.hpp

@@ -0,0 +1,49 @@
+#pragma once
+#include <iostream>
+#include <stack>
+#include <utility>
+#include <functional>
+#include <string>
+#include <iterator>
+#include <map>
+
+namespace dev
+{
+    /*!
+ * \brief Exception class for Calculator.
+ */
+    class Exception final : public std::exception
+    {
+    public:
+        template <typename T>
+        Exception(T &&msg)
+            : mMsg(std::forward<T>(msg))
+        {
+        }
+
+        const char *what() const noexcept override
+        {
+            return mMsg.c_str();
+        }
+
+    private:
+        const std::string mMsg;
+    };
+    using functionCall = std::function<double(double, double)>;
+    class PolishCalc
+    {
+    public:
+        double calc(const std::string &);
+        PolishCalc();
+
+    private:
+        bool isNumeric(const char num);
+        bool isOperator(const char num);
+        void insertFunctionInsideMap();
+        void pushOperandInStack(const std::string &str, int& curr_pos);
+        std::pair<double, double> getOperandFromStack();
+        std::stack<double> mCalculatorStack;
+        std::map<const char, functionCall> mOperatorMap;
+    };
+
+} // namespace dev

project.cc

@@ -5,4 +5,5 @@ namespace dev {
 int Project::run() {
   return 0;
 }
+
 }  // namespace dev

project.h

@@ -1,11 +1,14 @@
 #pragma once
 #include "iproject.h"
+#include "string"
 
-namespace dev {
+namespace dev
+{
 
-class Project : public IProject {
-  // IProject interface
- public:
-  int run();
-};
-}  // namespace dev
+  class Project : public IProject
+  {
+    // IProject interface
+  public:
+    int run();
+  };
+} // namespace dev

test/CMakeLists.txt

@@ -8,3 +8,6 @@ target_link_libraries(ProjectTest PUBLIC ProjectLib)
 
 add_executable (RunTest ${CMAKE_SOURCE_DIR}/run.cc run_tests.cc)
 add_gtest(RunTest)
+
+add_executable (CalculatorTest ${CMAKE_SOURCE_DIR}/polishNotationCalc.cpp calculator_test.cpp)
+add_gtest(CalculatorTest)

test/calculator_test.cpp

@@ -0,0 +1,53 @@
+#include "project.h"
+#include "polishNotationCalc.hpp"
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+namespace dev
+{
+    namespace testing
+    {
+
+        class CalculatorTest : public ::testing::Test
+        {
+        public:
+            void SetUp() override {}
+            void TearDown() override {}
+            dev::PolishCalc project_;
+        };
+        TEST_F(CalculatorTest, BasicOPTestWithInt)
+        {
+            EXPECT_EQ(7, project_.calc("5 2 +"));
+        }
+        TEST_F(CalculatorTest, BasicOPTestWithDouble)
+        {
+            EXPECT_EQ(7.8, project_.calc("5.5 2.3 +"));
+        }
+        TEST_F(CalculatorTest, MissingOperand)
+        {
+            EXPECT_ANY_THROW(project_.calc("5 +"));
+        }
+        TEST_F(CalculatorTest, MissingOperator)
+        {
+            EXPECT_ANY_THROW(project_.calc("5 2"));
+        }
+        TEST_F(CalculatorTest, EmptyString)
+        {
+            EXPECT_ANY_THROW(project_.calc(""));
+        }
+        TEST_F(CalculatorTest, DivideByZero)
+        {
+            EXPECT_ANY_THROW(project_.calc("7 0 /"));
+
+        }
+        TEST_F(CalculatorTest, PerformComplexOpeartions)
+        {
+            EXPECT_EQ(405, project_.calc("50 31 + 10 5 - * "));
+        }
+
+        TEST_F(CalculatorTest, MixingDoubleAndInt)
+        {
+            auto res = (int)project_.calc("12.5 3 / ");
+            EXPECT_EQ(4, res);
+        }
+    }
+}

test/project_test.cc

@@ -1,19 +1,24 @@
 #include "project.h"
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
-namespace dev {
-namespace testing {
+namespace dev
+{
+  namespace testing
+  {
 
-class ProjectTest : public ::testing::Test {
- public:
-  void SetUp() override {}
-  void TearDown() override {}
-  dev::Project project_;
-};
+    class ProjectTest : public ::testing::Test
+    {
+    public:
+      void SetUp() override {}
+      void TearDown() override {}
+      dev::Project project_;
+    };
 
-TEST_F(ProjectTest, Run) {
-  ASSERT_EQ(0, project_.run());
-}
+    TEST_F(ProjectTest, Run)
+    {
+      ASSERT_EQ(0, project_.run());
+    }
 
-}  // namespace testing
-}  // namespace dev
+  } // namespace testing
+  // namespace testing
+} // namespace dev