← 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/MathMLASTFragmentExpression.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/MathMLASTFragmentExpression.cpp
 
1
#include "MathMLSolverStableHeaders.h"
 
2
#include "MathMLASTFragmentExpression.h"
 
3
 
 
4
namespace MathML
 
5
{
 
6
 
 
7
    namespace AST
 
8
    {
 
9
        //---------------------------------------------------------------------------------
 
10
        FragmentExpression::FragmentExpression( const String& name, CloneFlags cloneFlags  )
 
11
                : 
 
12
                  mFragment( 0 )
 
13
                                , mName( name )
 
14
                                , mCloneFlags( cloneFlags )
 
15
        {}
 
16
 
 
17
        //---------------------------------------------------------------------------------
 
18
        FragmentExpression::~FragmentExpression()
 
19
        {
 
20
                        if ( mCloneFlags & CLONEFLAG_DEEPCOPY_FRAGMENT )
 
21
                        {
 
22
                                delete mFragment;
 
23
                        }
 
24
 
 
25
            // Parameters have to be deleted here
 
26
                        if ( mCloneFlags & CLONEFLAG_DEEPCOPY_FRAGMENT_PARAMS )
 
27
                        {
 
28
                                for (size_t i=0, count = mParameterList.size(); i<count; ++i)
 
29
                                {
 
30
                                        delete mParameterList.at( i );
 
31
                                }
 
32
                        }
 
33
        }
 
34
 
 
35
        //---------------------------------------------------------------------------------
 
36
        void FragmentExpression::accept( IVisitor* visitor ) const
 
37
        {
 
38
            visitor->visit( this );
 
39
        }
 
40
 
 
41
        //---------------------------------------------------------------------------------
 
42
        const String& FragmentExpression::getName() const
 
43
        {
 
44
            return mName;
 
45
        }
 
46
 
 
47
        //---------------------------------------------------------------------------------
 
48
        unsigned int FragmentExpression::getArgc() const
 
49
        {
 
50
            return mArgc;
 
51
        }
 
52
 
 
53
        //---------------------------------------------------------------------------------
 
54
        void FragmentExpression::setArgc( unsigned int argc )
 
55
        {
 
56
            mArgc = argc;
 
57
        }
 
58
 
 
59
        //---------------------------------------------------------------------------------
 
60
        INode* FragmentExpression::getFragment() const
 
61
        {
 
62
            return mFragment;
 
63
        }
 
64
 
 
65
        //---------------------------------------------------------------------------------
 
66
        void FragmentExpression::setFragment( INode* fragment )
 
67
        {
 
68
            mFragment = fragment;
 
69
        }
 
70
 
 
71
        //---------------------------------------------------------------------------------
 
72
        const FragmentExpression::ParameterList& FragmentExpression::getParameterList() const
 
73
        {
 
74
            return mParameterList;
 
75
        }
 
76
 
 
77
        //---------------------------------------------------------------------------------
 
78
        /*void FragmentExpression::setParameterList( const ParameterList& parameterList )
 
79
        {
 
80
            mParameterMap = parameterList;
 
81
        }*/
 
82
 
 
83
        //---------------------------------------------------------------------------------
 
84
        void FragmentExpression::addParameter( const String& parameterName, INode* parameter )
 
85
        {
 
86
            mParameterMap[parameterName] = parameter;
 
87
                        mParameterList.push_back(parameter);
 
88
                        if (mParameterSymbolSet.find(parameterName) == mParameterSymbolSet.end())
 
89
                                mParameterSymbolList.push_back(parameterName);
 
90
        }
 
91
                //-----------------------------------------------------------------------
 
92
                const FragmentExpression::ParameterMap& FragmentExpression::getParameterMap() const
 
93
                {
 
94
                        return mParameterMap;
 
95
                }
 
96
                //-----------------------------------------------------------------------
 
97
                void FragmentExpression::addParameterSymbol( const String& parameterSymbol )
 
98
                {       
 
99
                        if (mParameterSymbolSet.find(parameterSymbol) == mParameterSymbolSet.end())
 
100
                                mParameterSymbolList.push_back(parameterSymbol);
 
101
                }
 
102
                //-----------------------------------------------------------------------
 
103
                const FragmentExpression::ParameterSymbolList& FragmentExpression::getParameterSymbolList() const
 
104
                {
 
105
                        return mParameterSymbolList;
 
106
                }
 
107
 
 
108
        //-----------------------------------------------------------------
 
109
        INode* FragmentExpression::clone(CloneFlags cloneFlags) const
 
110
        {
 
111
            FragmentExpression* copy = new FragmentExpression( mName, cloneFlags );
 
112
            copy->mArgc = mArgc;
 
113
            if ( mFragment )
 
114
                        {
 
115
                                copy->mFragment = cloneFlags & CLONEFLAG_DEEPCOPY_FRAGMENT ?  mFragment->clone(cloneFlags) : mFragment;
 
116
                        }
 
117
            else
 
118
                        {
 
119
                copy->mFragment = 0;
 
120
                        }
 
121
 
 
122
                        if ( cloneFlags & CLONEFLAG_DEEPCOPY_FRAGMENT_PARAMS )
 
123
                        {
 
124
                                // A deep copy of the parameter nodes is required
 
125
                                copy->mParameterList.reserve(mParameterList.size());
 
126
                                ParameterMap::const_iterator it = mParameterMap.begin();
 
127
                                for ( ; it != mParameterMap.end(); ++it )
 
128
                                {
 
129
                                        const String& parameterName = it->first;
 
130
                                        const INode* parameterNode = it->second;
 
131
                                        INode* clonedParameterNode = parameterNode->clone(cloneFlags);
 
132
                                        copy->mParameterMap.insert(std::make_pair(parameterName, clonedParameterNode));
 
133
                                        copy->mParameterList.push_back(clonedParameterNode);
 
134
                                }
 
135
                        }
 
136
                        else
 
137
                        {
 
138
                                copy->mParameterMap = mParameterMap;
 
139
                                copy->mParameterList = mParameterList;
 
140
                        }
 
141
            copy->mParameterSymbolList = mParameterSymbolList;
 
142
            copy->mParameterSymbolSet = mParameterSymbolSet;
 
143
 
 
144
            return copy;
 
145
        }
 
146
 
 
147
    } //namespace AST
 
148
 
 
149
} //namespace MathML