The Big Programming Thread - Page 936

#pragma once

#include <inttypes.h>

enum class Operators : int32_t
{
    PLUS,
    MINUS,
    MULTIPLICATION,
    DIVISION,
    UNKNOWN
};

#pragma once

#include <inttypes.h>
#include <string>
#include <vector>

enum class Operators : int32_t;

class ReversePolishCalculator
{
public:
    ReversePolishCalculator();

    double calculate(const std::string& input) const;

private:
    std::vector<std::string> parseTokens(const std::string& input) const;
    bool parseOperator(const std::string& input, Operators& op) const;
    bool parseNumber(const std::string& input, int32_t& number) const;
    int32_t applyOperator(int32_t first, int32_t second, Operators op) const;
};

#include <sstream>
#include <algorithm>
#include <iterator>
#include <vector>
#include <stack>
#include <exception>
#include <cassert>
#include "ReversePolishCalculator.h"
#include "Operators.h"


ReversePolishCalculator::ReversePolishCalculator()
{
}

double ReversePolishCalculator::calculate(const std::string& input) const
{
    std::vector<std::string> tokens(parseTokens(input));
    std::stack<double> final_result;

    for (const std::string& token : tokens)
    {
        int32_t temp_number = 0;
        Operators temp_op = Operators::UNKNOWN;
        if (parseNumber(token, temp_number))
        {
            final_result.push(temp_number);
        }
        else if (parseOperator(token, temp_op))
        {
            if (final_result.size() <= 1)
                throw std::logic_error("Stack of numbers is either empty or it has only one number. Can't apply operator.");

            int32_t second = final_result.top();
            final_result.pop();

            int32_t first = final_result.top();
            final_result.pop();

            int32_t result = applyOperator(first, second, temp_op);
            final_result.push(result);
        }
    }

    bool has_one_result = final_result.size() == 1;

    if (!has_one_result)
        throw std::logic_error("Expected to have only one result");

    double the_result = static_cast<double>(final_result.top());
    final_result.pop();

    return the_result;
}

std::vector<std::string> ReversePolishCalculator::parseTokens(const std::string& input) const
{
    std::istringstream iss(input);
    std::vector<std::string> tokens{ std::istream_iterator<std::string>{iss},
        std::istream_iterator<std::string>{} };

    return tokens;
}

bool ReversePolishCalculator::parseOperator(const std::string& input, Operators& op) const
{
    bool success = false;

    if (input == "+")
    {
        op = Operators::PLUS;
        success = true;
    }
    else if (input == "-")
    {
        op = Operators::MINUS;
        success = true;
    }
    else if (input == "*" || input == "x")
    {
        op = Operators::MULTIPLICATION;
        success = true;
    }
    else if (input == "/")
    {
        op = Operators::DIVISION;
        success = true;
    }
    else
    {
        op = Operators::UNKNOWN;
        success = false;
    }

    return success;
}

bool ReversePolishCalculator::parseNumber(const std::string& input, int32_t& number) const
{
    int32_t converted_number = 0;

    try
    {
        converted_number = std::stoi(input);

        // if we're at this line, no exception has occurred
        number = converted_number;

        return true;
    }
    catch (const std::exception&)
    {
        return false;
    }
}

int32_t ReversePolishCalculator::applyOperator(int32_t first, int32_t second, Operators op) const
{
    switch (op)
    {
    case Operators::PLUS:
        return first + second;
    case Operators::MINUS:
        return first - second;
    case Operators::MULTIPLICATION:
        return first * second;
    case Operators::DIVISION:
        return first / second;
    case Operators::UNKNOWN:
    default:
    {
        throw std::logic_error("Unknown operators");
    }
    }
}