MATH_ParentExpression.h

Go to the documentation of this file.

#ifndef MATH_ParentExpression_H
#define MATH_ParentExpression_H

#include "MATH_Expression.h"


#include "MATH_ChildExpression.h"

DEFINE_SPTR(MATH_ParentExpression);
class MATH_ParentExpression : public MATH_Expression {
    SP_OBJECT(MATH_ParentExpression);
    // ATTRIBUTES
  
public:

  
private:

  
  
    // ASSOCIATION
    SV::MATH_ChildExpression mArguments;
  
  
protected: 
    // METHODS
  
    // CONSTRUCTORS 
  
    MATH_ParentExpression(void);
  
  
  
    // DESTRUCTORS 
  
    
    virtual ~MATH_ParentExpression(void);   
  

    // SET methods 
public:
 
    inline void setArgumentsNumber(const int& n) {
        mArguments.setSize(n);
    }
    virtual tBoolean addArgument(SP::MATH_ChildExpression operand);
    
    virtual tBoolean addArgument(MATH_ChildExpression* operand) {
        SP::MATH_ChildExpression sp;
        if (operand!=null) {
            operand->getSharedPointer(sp);
            return addArgument(sp);
        }
        return false;
    }
    tBoolean setArgument(const int& index,SP::MATH_ChildExpression org);
      
    inline tBoolean setArgument(const int& index,MATH_ChildExpression* arg) {
        SP::MATH_ChildExpression p;
        if (arg!=null) {
            arg->getSharedPointer(p);
        }
        return setArgument(index,p);
    }
    void resetArgument(const int& index);  
    inline void resetArguments() {
        for (int i=mArguments.getSize()-1;i>=0;i--)
            resetArgument(i);
    }
 
 
  
 
    // GET methods
public:

   
    virtual const MATH_RootExpression* getRootNode() const=0;
    
    inline SPC::MATH_ChildExpression getArgument(const int& i) const {
        return mArguments[i];
    }
    inline SP::MATH_ChildExpression getArgument(const int& i)  {
        return mArguments[i];
    }

    inline int getArgumentsNumber() const {
        return mArguments.getSize();
    }
    
public:
    
    // OTHERS methods
    virtual int evaluate(const tFlag& action,MATH_Environment& symbols,MATH_Variable& var) const {
        const MATH_ChildExpression *arg=null;
        int nArgs=mArguments.getSize();
        int retCode=0;
        for (int i=0;i<nArgs;i++) {
            arg=mArguments.get(i);
            if (arg!=null)  {
                retCode=arg->evaluate(action,symbols,var);
                if (retCode<0) return FAIL;
            }
        }
        return retCode;
    }
   
    virtual tString toString() const;

};

#endif