All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Defines
Public Types | Public Member Functions | Static Public Attributes | Static Protected Member Functions | Protected Attributes
QGpCoreTools::ExpressionAction Class Reference

#include <ExpressionAction.h>

Inheritance diagram for QGpCoreTools::ExpressionAction:
QGpCoreTools::XMLClass QGpCoreTools::ExpressionBracket QGpCoreTools::ExpressionFunction QGpCoreTools::ExpressionOperator QGpCoreTools::ExpressionValue QGpCoreTools::ExpressionVariable

List of all members.

Public Types

enum  Type {
  NoOperator, Assign, Sum, SumAssign,
  Subtract, SubtractAssign, Mult, MultAssign,
  FloatDiv, FloatDivAssign, IntMod, IntDiv,
  Coma, OpenBracket, CloseBracket, EndAction,
  Function, Equal, NotEqual, GreaterThan,
  GreaterOrEqual, LessThan, LessOrEqual, OpenSquareBracket,
  CloseSquareBracket, VariableArray
}

Public Member Functions

bool addAction (ExpressionAction *a)
virtual bool addArgument (ExpressionAction *a)=0
virtual ExpressionAction * close (ExpressionAction::Type t)
 ExpressionAction ()
virtual bool isReadOnly () const
virtual ExpressionAction * parent () const
virtual int priority () const
virtual void replaceArgument (ExpressionAction *oldA, ExpressionAction *newA)=0
void setParent (ExpressionAction *p)
virtual void setValue (const QVariant &)
ExpressionAction * superParent ()
virtual QVariant value () const =0
virtual const QString & xml_tagName () const
virtual ~ExpressionAction ()

Static Public Attributes

static const QString xmlExpressionActionTag = "ExpressionAction"

Static Protected Member Functions

static int compare (const QVariant &op1, const QVariant &op2, bool &ok)
static QVariant floatDiv (const QVariant &op1, const QVariant &op2)
static QVariant mult (const QVariant &op1, const QVariant &op2)
static QVariant subtract (const QVariant &op1, const QVariant &op2)
static QVariant sum (const QVariant &op1, const QVariant &op2)

Protected Attributes

ExpressionAction * _parent

Member Enumeration Documentation

enum QGpCoreTools::ExpressionAction::Type
Enumerator:
NoOperator 
Assign 
Sum 
SumAssign 
Subtract 
SubtractAssign 
Mult 
MultAssign 
FloatDiv 
FloatDivAssign 
IntMod 
IntDiv 
Coma 
OpenBracket 
CloseBracket 
EndAction 
Function 
Equal 
NotEqual 
GreaterThan 
GreaterOrEqual 
LessThan 
LessOrEqual 
OpenSquareBracket 
CloseSquareBracket 
VariableArray  
            {NoOperator, Assign, Sum, SumAssign, Subtract, SubtractAssign, Mult, MultAssign, FloatDiv,
             FloatDivAssign, IntMod, IntDiv, Coma, OpenBracket, CloseBracket, EndAction, Function, Equal,
             NotEqual, GreaterThan, GreaterOrEqual, LessThan, LessOrEqual, OpenSquareBracket, CloseSquareBracket,
             VariableArray};

Constructor & Destructor Documentation

QGpCoreTools::ExpressionAction::ExpressionAction ( ) [inline] 
{_parent=0;}
virtual QGpCoreTools::ExpressionAction::~ExpressionAction ( ) [inline, virtual] 
{}

Member Function Documentation

bool QGpCoreTools::ExpressionAction::addAction ( ExpressionAction *  a)

References addAction(), addArgument(), parent(), priority(), and TRACE.

Referenced by addAction().

{
  TRACE;
  if(parent() && a->priority()<priority()) {
    return parent()->addAction(a);
  } else {
    return addArgument(a);
  }
}
virtual bool QGpCoreTools::ExpressionAction::addArgument ( ExpressionAction *  a) [pure virtual]

Implemented in QGpCoreTools::ExpressionFunction, QGpCoreTools::ExpressionOperator, QGpCoreTools::ExpressionBracket, QGpCoreTools::ExpressionValue, and QGpCoreTools::ExpressionVariable.

Referenced by addAction(), QGpCoreTools::ExpressionVariable::addArgument(), QGpCoreTools::ExpressionBracket::addArgument(), QGpCoreTools::ExpressionOperator::addArgument(), and QGpCoreTools::ExpressionFunction::addArgument().

ExpressionAction * QGpCoreTools::ExpressionAction::close ( ExpressionAction::Type  t) [virtual]

Reimplemented in QGpCoreTools::ExpressionFunction, QGpCoreTools::ExpressionBracket, and QGpCoreTools::ExpressionVariable.

References _parent, close(), and TRACE.

Referenced by close().

{
  TRACE;
  if(_parent) return _parent->close(t); else return 0;
}
int QGpCoreTools::ExpressionAction::compare ( const QVariant &  op1,
const QVariant &  op2,
bool &  ok 
) [static, protected]

Compares two variants

References TRACE.

Referenced by QGpCoreTools::ExpressionOperator::value().

{
  TRACE;
  ok=true;
  switch (op1.type()) {
  case QVariant::Double:
  case QVariant::Int:
    switch (op2.type()) {
    case QVariant::Double:
    case QVariant::Int: {
        double op1d=op1.toDouble();
        double op2d=op2.toDouble();
        if(op1d<op2d) return -1;
        else if(op1d>op2d) return 1;
        else return 0;
      }
    case QVariant::String: {
        QString op1s=op1.toString();
        QString op2s=op2.toString();
        if(op1s<op2s) return -1;
        else if(op1s>op2s) return 1;
        else return 0;
      }
    default:
      ok=false;
      return 0;
    }
  case QVariant::String:
    switch (op2.type()) {
    case QVariant::String:
    case QVariant::Double:
    case QVariant::Int: {
        QString op1s=op1.toString();
        QString op2s=op2.toString();
        if(op1s<op2s) return -1;
        else if(op1s>op2s) return 1;
        else return 0;
      }
    default:
      ok=false;
      return 0;
    }
  default:
    ok=false;
    return 0;
  }
}
QVariant QGpCoreTools::ExpressionAction::floatDiv ( const QVariant &  op1,
const QVariant &  op2 
) [static, protected]

Calculate the division of two variants

References QGpCoreTools::endl(), QGpCoreTools::App::stream(), QGpCoreTools::tr(), and TRACE.

Referenced by QGpCoreTools::ExpressionOperator::value().

{
  TRACE;
  double val;
  bool ok;
  switch (op1.type()) {
  case QVariant::Double:
    switch (op2.type()) {
    case QVariant::Double:
    case QVariant::Int:
      return op1.toDouble()/op2.toDouble();
    case QVariant::String:
      val=op2.toString().toDouble(&ok);
      if(ok)
        return op1.toDouble()/val;
      else
        return QVariant();
    default:
      return QVariant();
    }
  case QVariant::Int:
    switch (op2.type()) {
    case QVariant::Double:
      return op1.toDouble()/op2.toDouble();
    case QVariant::Int: {
        int v2=op2.toInt();
        if(v2!=0) {
          return op1.toInt()/v2;
        } else {
          App::stream() << tr("Division by zero") << endl;
          return QVariant();
        }
      }
    case QVariant::String:
      val=op2.toString().toDouble(&ok);
      if(ok)
        return op1.toDouble()/val;
      else {
        App::stream() << tr("Division by zero") << endl;
        return QVariant();
      }
    default:
      App::stream() << tr("Division by zero") << endl;
      return QVariant();
    }
  case QVariant::String:
    val=op1.toString().toDouble(&ok);
    if(ok) {
      double val2=op2.toString().toDouble(&ok);
      if(ok)
        return val/val2;
      else {
        App::stream() << tr("Division by zero") << endl;
        return QVariant();
      }
    } else {
      return 0.0;
    }
  default:
    return QVariant();
  }
}
virtual bool QGpCoreTools::ExpressionAction::isReadOnly ( ) const [inline, virtual]

Reimplemented in QGpCoreTools::ExpressionBracket, and QGpCoreTools::ExpressionVariable.

Referenced by QGpCoreTools::ExpressionOperator::value().

{return true;}
QVariant QGpCoreTools::ExpressionAction::mult ( const QVariant &  op1,
const QVariant &  op2 
) [static, protected]

Calculate the multiplication of two variants

References TRACE.

Referenced by QGpCoreTools::ExpressionOperator::value().

{
  TRACE;
  double val;
  bool ok;
  switch (op1.type()) {
  case QVariant::Double:
    switch (op2.type()) {
    case QVariant::Double:
    case QVariant::Int:
      return op1.toDouble()*op2.toDouble();
    case QVariant::String:
      val=op2.toString().toDouble(&ok);
      if(ok)
        return op1.toDouble()*val;
      else
        return 0.0;
    default:
      return QVariant();
    }
  case QVariant::Int:
    switch (op2.type()) {
    case QVariant::Double:
      return op1.toDouble()*op2.toDouble();
    case QVariant::Int:
      return op1.toInt()*op2.toInt();
    case QVariant::String:
      val=op2.toString().toDouble(&ok);
      if(ok)
        return op1.toDouble()*val;
      else
        return 0.0;
    default:
      return QVariant();
    }
  case QVariant::String:
    val=op1.toString().toDouble(&ok);
    if(ok) {
      double val2=op2.toString().toDouble(&ok);
      if(ok)
        return val*val2;
      else
        return 0.0;
    } else {
      return 0.0;
    }
  default:
    return QVariant();
  }
}
virtual ExpressionAction* QGpCoreTools::ExpressionAction::parent ( ) const [inline, virtual]

Reimplemented in QGpCoreTools::ExpressionFunction, QGpCoreTools::ExpressionBracket, and QGpCoreTools::ExpressionVariable.

Referenced by addAction(), and QGpCoreTools::ExpressionOperator::addArgument().

{return _parent;}
virtual int QGpCoreTools::ExpressionAction::priority ( ) const [inline, virtual]

Reimplemented in QGpCoreTools::ExpressionOperator.

Referenced by addAction(), and QGpCoreTools::ExpressionOperator::addArgument().

{return 4;}
virtual void QGpCoreTools::ExpressionAction::replaceArgument ( ExpressionAction *  oldA,
ExpressionAction *  newA 
) [pure virtual]

Implemented in QGpCoreTools::ExpressionFunction, QGpCoreTools::ExpressionOperator, QGpCoreTools::ExpressionBracket, QGpCoreTools::ExpressionValue, and QGpCoreTools::ExpressionVariable.

Referenced by QGpCoreTools::ExpressionOperator::addArgument().

void QGpCoreTools::ExpressionAction::setParent ( ExpressionAction *  p) [inline]

Referenced by QGpCoreTools::ExpressionVariable::addArgument(), QGpCoreTools::ExpressionBracket::addArgument(), QGpCoreTools::ExpressionOperator::addArgument(), QGpCoreTools::ExpressionFunction::addArgument(), QGpCoreTools::ExpressionVariable::replaceArgument(), QGpCoreTools::ExpressionBracket::replaceArgument(), QGpCoreTools::ExpressionOperator::replaceArgument(), and QGpCoreTools::ExpressionFunction::replaceArgument().

{_parent=p;}
virtual void QGpCoreTools::ExpressionAction::setValue ( const QVariant &  ) [inline, virtual]

Reimplemented in QGpCoreTools::ExpressionVariable.

Referenced by QGpCoreTools::ExpressionOperator::value().

{}
QVariant QGpCoreTools::ExpressionAction::subtract ( const QVariant &  op1,
const QVariant &  op2 
) [static, protected]

Calculate the subtraction of two variants

References TRACE.

Referenced by QGpCoreTools::ExpressionOperator::value().

{
  TRACE;
  double val;
  bool ok;
  switch (op1.type()) {
  case QVariant::Double:
    switch (op2.type()) {
    case QVariant::Double:
    case QVariant::Int:
      return op1.toDouble()-op2.toDouble();
    case QVariant::String:
      val=op2.toString().toDouble(&ok);
      if(ok)
        return op1.toDouble()-val;
      else
        return op1;
    default:
      return op1;
    }
  case QVariant::Int:
    switch (op2.type()) {
    case QVariant::Double:
      return op1.toDouble()-op2.toDouble();
    case QVariant::Int:
      return op1.toInt()-op2.toInt();
    case QVariant::String:
      val=op2.toString().toDouble(&ok);
      if(ok)
        return op1.toDouble()-val;
      else
        return op1;
    default:
      return op1;
    }
  case QVariant::String:
    val=op1.toString().toDouble(&ok);
    if(ok) {
      double val2=op2.toString().toDouble(&ok);
      if(ok)
        return val-val2;
      else
        return val;
    } else {
      val=op2.toString().toDouble(&ok);
      if(ok)
        return -val;
      else
        return QVariant();
    }
  default:
    switch (op2.type()) {
    case QVariant::Double:
    case QVariant::Int:
      return -op2.toDouble();
    default:
      return QVariant();
    }
  }
}
QVariant QGpCoreTools::ExpressionAction::sum ( const QVariant &  op1,
const QVariant &  op2 
) [static, protected]

Calculate the sum of two variants: either the arithmetic sum or concatenation

References TRACE.

Referenced by QGpCoreTools::ExpressionOperator::value().

{
  TRACE;
  double val;
  bool ok;
  switch (op1.type()) {
  case QVariant::Double:
    switch (op2.type()) {
    case QVariant::Double:
    case QVariant::Int:
      return op1.toDouble()+op2.toDouble();
    case QVariant::String:
      val=op2.toString().toDouble(&ok);
      if(ok)
        return op1.toDouble()+val;
      else
        return op1.toString()+op2.toString();
    default:
      return op1;
    }
  case QVariant::Int:
    switch (op2.type()) {
    case QVariant::Double:
      return op1.toDouble()+op2.toDouble();
    case QVariant::Int:
      return op1.toInt()+op2.toInt();
    case QVariant::String:
      val=op2.toString().toDouble(&ok);
      if(ok)
        return op1.toDouble()+val;
      else
        return op1.toString()+op2.toString();
    default:
      return op1;
    }
  case QVariant::String:
    switch (op2.type()) {
    case QVariant::Double:
      val=op1.toString().toDouble(&ok);
      if(ok)
        return val+op2.toDouble();
      else
        return op1.toString()+op2.toString();
    case QVariant::Int:
      val=op1.toString().toDouble(&ok);
      if(ok)
        return val+op2.toInt();
      else
        return op1.toString()+op2.toString();
    case QVariant::String:
      return op1.toString()+op2.toString();
    default:
      return op1;
    }
  default:
    switch (op2.type()) {
    case QVariant::Double:
    case QVariant::Int:
    case QVariant::String:
      return op2;
    default:
      return QVariant();
    }
  }
}
ExpressionAction * QGpCoreTools::ExpressionAction::superParent ( )

References _parent, superParent(), and TRACE.

Referenced by superParent().

{
  TRACE;
  if(_parent) return _parent->superParent(); else return this;
}
virtual QVariant QGpCoreTools::ExpressionAction::value ( ) const [pure virtual]

Implemented in QGpCoreTools::ExpressionFunction, QGpCoreTools::ExpressionOperator, QGpCoreTools::ExpressionBracket, QGpCoreTools::ExpressionValue, and QGpCoreTools::ExpressionVariable.

Referenced by QGpCoreTools::ExpressionVariable::setValue(), QGpCoreTools::ExpressionVariable::value(), and QGpCoreTools::ExpressionOperator::value().

virtual const QString& QGpCoreTools::ExpressionAction::xml_tagName ( ) const [inline, virtual]

Implements QGpCoreTools::XMLClass.

Reimplemented in QGpCoreTools::ExpressionFunction, QGpCoreTools::ExpressionOperator, QGpCoreTools::ExpressionBracket, QGpCoreTools::ExpressionValue, and QGpCoreTools::ExpressionVariable.

{return xmlExpressionActionTag;}

Member Data Documentation

ExpressionAction* QGpCoreTools::ExpressionAction::_parent [protected]

Referenced by close(), QGpCoreTools::ExpressionVariable::close(), QGpCoreTools::ExpressionBracket::close(), QGpCoreTools::ExpressionFunction::close(), and superParent().

const QString QGpCoreTools::ExpressionAction::xmlExpressionActionTag = "ExpressionAction" [static]
The documentation for this class was generated from the following files:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Defines

Modified 2013-10-22

Valid CSS! Valid XHTML 1.0!