void CHistoryCollector::AddUnaryOpToHistory()

in src/CalcManager/CEngine/History.cpp [214:326]
105 lines of code
33 McCabe index (conditional complexity)

void CHistoryCollector::AddUnaryOpToHistory(int nOpCode, bool fInv, AngleType angletype)
{
    int iCommandEnd;
    // When successfully applying a unary op, there should be an opnd already
    // A very special case of % which is a funny post op unary op.
    if (IDC_PERCENT == nOpCode)
    {
        iCommandEnd = AddCommand(std::make_shared<CUnaryCommand>(nOpCode));
        IchAddSzToEquationSz(CCalcEngine::OpCodeToString(nOpCode), iCommandEnd);
    }
    else // all the other unary ops
    {
        std::shared_ptr<IOperatorCommand> spExpressionCommand;
        if (IDC_SIGN == nOpCode)
        {
            spExpressionCommand = std::make_shared<CUnaryCommand>(nOpCode);
        }
        else
        {
            CalculationManager::Command angleOpCode;
            if (angletype == AngleType::Degrees)
            {
                angleOpCode = CalculationManager::Command::CommandDEG;
            }
            else if (angletype == AngleType::Radians)
            {
                angleOpCode = CalculationManager::Command::CommandRAD;
            }
            else // (angletype == AngleType::Gradians)
            {
                angleOpCode = CalculationManager::Command::CommandGRAD;
            }

            int command = nOpCode;
            switch (nOpCode)
            {
            case IDC_SIN:
                command = fInv ? static_cast<int>(CalculationManager::Command::CommandASIN) : IDC_SIN;
                spExpressionCommand = std::make_shared<CUnaryCommand>(static_cast<int>(angleOpCode), command);
                break;
            case IDC_COS:
                command = fInv ? static_cast<int>(CalculationManager::Command::CommandACOS) : IDC_COS;
                spExpressionCommand = std::make_shared<CUnaryCommand>(static_cast<int>(angleOpCode), command);
                break;
            case IDC_TAN:
                command = fInv ? static_cast<int>(CalculationManager::Command::CommandATAN) : IDC_TAN;
                spExpressionCommand = std::make_shared<CUnaryCommand>(static_cast<int>(angleOpCode), command);
                break;
            case IDC_SINH:
                command = fInv ? static_cast<int>(CalculationManager::Command::CommandASINH) : IDC_SINH;
                spExpressionCommand = std::make_shared<CUnaryCommand>(command);
                break;
            case IDC_COSH:
                command = fInv ? static_cast<int>(CalculationManager::Command::CommandACOSH) : IDC_COSH;
                spExpressionCommand = std::make_shared<CUnaryCommand>(command);
                break;
            case IDC_TANH:
                command = fInv ? static_cast<int>(CalculationManager::Command::CommandATANH) : IDC_TANH;
                spExpressionCommand = std::make_shared<CUnaryCommand>(command);
                break;
            case IDC_SEC:
                command = fInv ? static_cast<int>(CalculationManager::Command::CommandASEC) : IDC_SEC;
                spExpressionCommand = std::make_shared<CUnaryCommand>(static_cast<int>(angleOpCode), command);
                break;
            case IDC_CSC:
                command = fInv ? static_cast<int>(CalculationManager::Command::CommandACSC) : IDC_CSC;
                spExpressionCommand = std::make_shared<CUnaryCommand>(static_cast<int>(angleOpCode), command);
                break;
            case IDC_COT:
                command = fInv ? static_cast<int>(CalculationManager::Command::CommandACOT) : IDC_COT;
                spExpressionCommand = std::make_shared<CUnaryCommand>(static_cast<int>(angleOpCode), command);
                break;
            case IDC_SECH:
                command = fInv ? static_cast<int>(CalculationManager::Command::CommandASECH) : IDC_SECH;
                spExpressionCommand = std::make_shared<CUnaryCommand>(command);
                break;
            case IDC_CSCH:
                command = fInv ? static_cast<int>(CalculationManager::Command::CommandACSCH) : IDC_CSCH;
                spExpressionCommand = std::make_shared<CUnaryCommand>(command);
                break;
            case IDC_COTH:
                command = fInv ? static_cast<int>(CalculationManager::Command::CommandACOTH) : IDC_COTH;
                spExpressionCommand = std::make_shared<CUnaryCommand>(command);
                break;
            case IDC_LN:
                command = fInv ? static_cast<int>(CalculationManager::Command::CommandPOWE) : IDC_LN;
                spExpressionCommand = std::make_shared<CUnaryCommand>(command);
                break;
            default:
                spExpressionCommand = std::make_shared<CUnaryCommand>(nOpCode);
            }
        }

        iCommandEnd = AddCommand(spExpressionCommand);

        wstring operandStr{ CCalcEngine::OpCodeToUnaryString(nOpCode, fInv, angletype) };
        if (!m_bLastOpndBrace) // The opnd is already covered in braces. No need for additional braces around it
        {
            operandStr.append(CCalcEngine::OpCodeToString(IDC_OPENP));
        }
        InsertSzInEquationSz(operandStr, iCommandEnd, m_lastOpStartIndex);

        if (!m_bLastOpndBrace)
        {
            IchAddSzToEquationSz(CCalcEngine::OpCodeToString(IDC_CLOSEP), -1);
        }
    }

    SetExpressionDisplay();
    m_bLastOpndBrace = false;
    // m_lastOpStartIndex remains the same as last opnd is just replaced by unaryop(lastopnd)
    m_lastBinOpStartIndex = -1;
}