Maxim realization

CMakeLists.txt

@@ -2,9 +2,12 @@ cmake_minimum_required(VERSION 3.5.1)
 project(dummy_cmake_project)
 
 set(CMAKE_CXX_STANDARD 14)
+
+set(CMAKE_INCLUDE_CURRENT_DIR ON)
+
 list(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake)
 
-set(SOURCES project.cc)
+set(SOURCES project.cc constant.h project_operation.h project_operation.cpp)
 add_library(ProjectLib ${SOURCES})
 
 add_executable(project main.cc)

README.md

@@ -0,0 +1 @@
+# Polish_notation

constant.h

@@ -0,0 +1,24 @@
+#ifndef CONSTANT
+#define CONSTANT
+
+#include <limits>
+#include <stack>
+
+namespace polish_notation_constant
+{
+    typedef double value_t;
+    typedef std::stack<value_t> stack_numbers_t;
+
+    constexpr value_t ERROR_VALUE = std::numeric_limits<value_t>::max();
+
+    enum class error_code {
+        STACK_EMPTY,
+        NOT_CORRECT_EXPRESSION,
+        ZERO_DEVISION,
+        NO_ERROR,
+        NOT_CORRECT_COUNT_OF_OPERATION
+    };
+}
+
+#endif // CONSTANT
+

iproject.h

@@ -1,9 +1,10 @@
 #pragma once
+#include <string>
 
 namespace dev{
 
 class IProject {
-  virtual int run() = 0;
+    virtual double run(std::string) = 0;
 };
 
 }

main.cc

@@ -1,5 +1,21 @@
 #include "project.h"
+#include "constant.h"
+#include <iostream>
+#include <string>
 
-int main() {
-  return 0;
+int main()
+{
+    dev::Project project;
+    auto value = project.run("2 2 +");
+
+    if( value != polish_notation_constant::ERROR_VALUE)
+    {
+       std::cout << "Result: " <<  value << std::endl;
+    }
+    else
+    {
+        std::cout << "Error code: " << project.get_error_code()  << std::endl;
+    }
+
+    return 0;
 }

project.cc

@@ -2,7 +2,133 @@
 
 namespace dev {
 
-int Project::run() {
-  return 0;
+
+value_t Project::run(std::string input_str) {
+
+    return processData(input_str);
+}
+
+
+bool Project::is_valid_count_value(stack_numbers_t& stack)
+{
+    if (stack.size() < 2) {
+        error_code_val = error_code::NOT_CORRECT_COUNT_OF_OPERATION;
+
+        return false;
+    }
+    else
+    {
+        return true;
+    }
+}
+
+value_t Project::take_value_from_stack(stack_numbers_t& stack)
+{
+    value_t value = ERROR_VALUE;
+
+    if (stack.size() != 0) {
+        value = stack.top();
+        stack.pop();
+    }
+    else{
+        error_code_val = error_code::STACK_EMPTY;
+    }
+
+    return value;
+}
+
+
+
+bool Project::is_number(const std::string& s)
+{
+    char* end = 0;
+    double val = std::strtod(s.c_str(), &end);
+    return end != s.c_str() && *end == '\0' && val != HUGE_VAL;
+}
+
+void Project::clear_stack(stack_numbers_t & stack)
+{
+    while(!stack.empty())
+    {
+        stack.pop();
+    }
+}
+
+int Project::get_error_code()
+{
+    return static_cast<uint32_t>(error_code_val);
+}
+
+value_t Project::calculateStackValue(std::string temp_str, stack_numbers_t& stack_numbers)
+{
+    double left_operand, right_operand;
+
+    right_operand = take_value_from_stack(stack_numbers);
+    left_operand  = take_value_from_stack(stack_numbers);
+
+    left_operand = project_operation_.make_operation(temp_str[0], left_operand, right_operand);
+
+    if(left_operand == ERROR_VALUE)
+    {
+        error_code_val = error_code::NOT_CORRECT_EXPRESSION;
+        return ERROR_VALUE;
+    }
+
+    if(left_operand != polish_notation_constant::ERROR_VALUE && temp_str[0] == '/') {
+        error_code_val = error_code::ZERO_DEVISION;
+    }
+
+    return left_operand;
+}
+
+value_t Project::processData(std::string& input_str)
+{
+    stack_numbers_t stack_numbers;
+    error_code_val = error_code::NO_ERROR;
+
+    value_t return_value = ERROR_VALUE;
+    std::istringstream f(input_str);
+    std::string temp_str;
+
+
+    while (std::getline(f, temp_str, ' ')) {
+        std::cout << "Stack value: " << temp_str << std::endl;
+
+        if(is_number(temp_str)) {
+            stack_numbers.push(std::stod(temp_str.c_str()));
+        }
+        else {
+            if (true == is_valid_count_value(stack_numbers)) {
+                value_t value = calculateStackValue(temp_str, stack_numbers);
+
+                if (value != ERROR_VALUE){
+                    stack_numbers.push(value);
+                }
+                else{
+                    break;
+                }
+
+            } else {
+                error_code_val = error_code::NOT_CORRECT_COUNT_OF_OPERATION;
+            }
+        }
+
+        if(error_code_val != error_code::NO_ERROR) {
+                    clear_stack(stack_numbers);
+                    break;
+        }
+    }
+
+
+    if (input_str.empty())
+    {
+        error_code_val = error_code::STACK_EMPTY;
+    }
+
+    if (stack_numbers.size() != 0) {
+        return_value = stack_numbers.top();
+    }
+
+    return return_value;
 }
 }  // namespace dev

project.cc.autosave

@@ -0,0 +1,134 @@
+#include "project.h"
+
+namespace dev {
+
+
+value_t Project::run(std::string input_str) {
+
+    return processData(input_str);
+}
+
+
+bool Project::is_valid_count_value(stack_numbers_t& stack)
+{
+    if (stack.size() < 2) {
+        error_code_val = error_code::NOT_CORRECT_COUNT_OF_OPERATION;
+
+        return false;
+    }
+    else
+    {
+        return true;
+    }
+}
+
+value_t Project::take_value_from_stack(stack_numbers_t& stack)
+{
+    value_t value = ERROR_VALUE;
+
+    if (stack.size() != 0) {
+        value = stack.top();
+        stack.pop();
+    }
+    else{
+        error_code_val = error_code::STACK_EMPTY;
+    }
+
+    return value;
+}
+
+
+
+bool Project::is_number(const std::string& s)
+{
+    char* end = 0;
+    double val = std::strtod(s.c_str(), &end);
+    return end != s.c_str() && *end == '\0' && val != HUGE_VAL;
+}
+
+void Project::clear_stack(stack_numbers_t & stack)
+{
+    while(!stack.empty())
+    {
+        stack.pop();
+    }
+}
+
+int Project::get_error_code()
+{
+    return static_cast<uint32_t>(error_code_val);
+}
+
+value_t Project::calculateStackValue(std::string temp_str, stack_numbers_t& stack_numbers)
+{
+    double left_operand, right_operand;
+
+    right_operand = take_value_from_stack(stack_numbers);
+    left_operand  = take_value_from_stack(stack_numbers);
+
+    left_operand = project_operation_.make_operation(temp_str[0], left_operand, right_operand);
+
+    if(left_operand == ERROR_VALUE)
+    {
+        error_code_val = error_code::NOT_CORRECT_EXPRESSION;
+        return ERROR_VALUE;
+    }
+
+    if(left_operand != polish_notation_constant::ERROR_VALUE && temp_str[0] == '/') {
+        error_code_val = error_code::ZERO_DEVISION;
+    }
+
+    return left_operand;
+}
+
+value_t Project::processData(std::string& input_str)
+{
+    stack_numbers_t stack_numbers;
+    error_code_val = error_code::NO_ERROR;
+
+    value_t return_value = ERROR_VALUE;
+    std::istringstream f(input_str);
+    std::string temp_str;
+
+
+    while (std::getline(f, temp_str, ' ')) {
+        std::cout << "Stack value: " << temp_str << std::endl;
+
+        if(is_number(temp_str)) {
+            stack_numbers.push(std::stod(temp_str.c_str()));
+        }
+        else {
+            if (is_valid_count_value(stack_numbers) == true) {
+                value_t value = calculateStackValue(temp_str, stack_numbers);
+
+                if (value != ERROR_VALUE){
+                    stack_numbers.push(value);
+                }
+                else{
+                    break;
+                }
+
+            } else {
+                error_code_val = error_code::NOT_CORRECT_COUNT_OF_OPERATION;
+            }
+        }
+
+        if(error_code_val != error_code::NO_ERROR) {
+                    clear_stack(stack_numbers);
+                    break;
+        }
+    }
+
+
+    if (input_str.empty())
+    {
+        error_code_val = error_code::STACK_EMPTY;
+    }
+
+    if (stack_numbers.size() != 0) {
+        return_value = stack_numbers.top();
+    }
+
+    return return_value;
+}
+}  // namespace dev

project.h

@@ -1,11 +1,43 @@
 #pragma once
 #include "iproject.h"
+#include "constant.h"
+#include "project_operation.h"
+
+#include <array>
+#include <cctype>
+#include <string>
+#include <sstream>
+#include <iostream>
+#include <algorithm>
+
 
 namespace dev {
 
+using namespace polish_notation_constant;
+
+
 class Project : public IProject {
-  // IProject interface
+    typedef error_code error_t;
+
+    // IProject interface
  public:
-  int run();
+    double run(std::string);
+
+    int get_error_code();
+
+private:
+    void clear_stack(stack_numbers_t&);
+    value_t calculateStackValue(std::string temp_str, stack_numbers_t& stack_numbers);
+
+    value_t take_value_from_stack();
+    value_t processData(std::string& input_str);
+    value_t take_value_from_stack(stack_numbers_t&);
+
+    bool is_valid_count_value(stack_numbers_t&);
+    bool is_number(const std::string& s);
+
+
+    project_operation project_operation_;
+    error_t error_code_val = error_code::NO_ERROR;
 };
 }  // namespace dev