← Back to branch summary

~ubuntu-branches/ubuntu/wily/opencollada/wily-proposed

« back to all changes in this revision

Viewing changes to Externals/MathMLSolver/src/AST/MathMLASTLogicExpression.cpp

  • Committer: Package Import Robot
  • Author(s): Matteo F. Vescovi
  • Date: 2015-05-14 17:23:27 UTC
  • Revision ID: package-import@ubuntu.com-20150514172327-f862u8envms01fra
Tags: upstream-0.1.0~20140703.ddf8f47+dfsg1
Import upstream version 0.1.0~20140703.ddf8f47+dfsg1

Show diffs side-by-side

added added

removed removed

Lines of Context:
Externals/MathMLSolver/src/AST/MathMLASTLogicExpression.cpp
 
1
#include "MathMLSolverStableHeaders.h"
 
2
#include "MathMLASTLogicExpression.h"
 
3
 
 
4
namespace MathML
 
5
{
 
6
 
 
7
    namespace AST
 
8
    {
 
9
        //---------------------------------------------------------------------------------
 
10
        LogicExpression::LogicExpression()
 
11
            : mOperator( AND )
 
12
        {}
 
13
 
 
14
        //---------------------------------------------------------------------------------
 
15
        LogicExpression::~LogicExpression()
 
16
        {
 
17
            for (size_t i=0; i<mOperands.size(); ++i)
 
18
            {
 
19
                delete mOperands.at( i );
 
20
            }
 
21
        }
 
22
 
 
23
        //---------------------------------------------------------------------------------
 
24
        void LogicExpression::accept( IVisitor* visitor ) const
 
25
        {
 
26
            visitor->visit( this );
 
27
        }
 
28
 
 
29
        //---------------------------------------------------------------------------------
 
30
        LogicExpression::Operator LogicExpression::getOperator() const
 
31
        {
 
32
            return mOperator;
 
33
        }
 
34
 
 
35
        //---------------------------------------------------------------------------------
 
36
        void LogicExpression::setOperator( Operator op )
 
37
        {
 
38
            mOperator = op;
 
39
        }
 
40
 
 
41
        //---------------------------------------------------------------------------------
 
42
        String LogicExpression::getOperatorString() const
 
43
        {
 
44
            return operatorString( mOperator );
 
45
        }
 
46
 
 
47
        //---------------------------------------------------------------------------------
 
48
        String LogicExpression::operatorString( Operator op )
 
49
        {
 
50
            switch ( op )
 
51
            {
 
52
 
 
53
            case AND:
 
54
                return OPERATOR_LOGIC_AND;
 
55
 
 
56
            case OR:
 
57
                return OPERATOR_LOGIC_OR;
 
58
 
 
59
            case XOR:
 
60
                return OPERATOR_LOGIC_XOR;
 
61
            }
 
62
 
 
63
            return OPERATOR_LOGIC_ILLEGAL;
 
64
        }
 
65
 
 
66
        //---------------------------------------------------------------------------------
 
67
        void LogicExpression::setOperator( const String& op )
 
68
        {
 
69
            if ( op == OPERATOR_LOGIC_AND )
 
70
            {
 
71
                mOperator = AND;
 
72
            }
 
73
 
 
74
            else if ( op == OPERATOR_LOGIC_OR )
 
75
            {
 
76
                mOperator = OR;
 
77
            }
 
78
 
 
79
            else if ( op == OPERATOR_LOGIC_XOR )
 
80
            {
 
81
                mOperator = XOR;
 
82
            }
 
83
        }
 
84
 
 
85
                //---------------------------------------------------------------------------------
 
86
                const NodeList& LogicExpression::getOperands() const
 
87
                {
 
88
                        return mOperands;
 
89
                }
 
90
 
 
91
                //---------------------------------------------------------------------------------
 
92
                NodeList& LogicExpression::getOperands()
 
93
                {
 
94
                        return mOperands;
 
95
                }
 
96
 
 
97
        //---------------------------------------------------------------------------------
 
98
        void LogicExpression::addOperand( INode* operand )
 
99
        {
 
100
            mOperands.push_back( operand );
 
101
        }
 
102
 
 
103
        //-----------------------------------------------------------------
 
104
        INode* LogicExpression::clone(CloneFlags cloneFlags) const
 
105
        {
 
106
            LogicExpression* copy = new LogicExpression();
 
107
            copy->mOperator = mOperator;
 
108
            for (size_t i=0; i<mOperands.size(); ++i)
 
109
            {
 
110
                copy->mOperands.push_back( mOperands.at( i )->clone(cloneFlags) );
 
111
            }
 
112
            return copy;
 
113
        }
 
114
 
 
115
    } //namespace AST
 
116
 
 
117
} //namespace MathML