[prev in list] [next in list] [prev in thread] [next in thread]
List: kde-commits
Subject: [analitza] analitza: REVIEW: 115439
From: Percy_Camilo_Triveño_Aucahuasi <percy.camilo.ta () gmail ! com>
Date: 2014-02-15 17:04:00
Message-ID: E1WEiem-0008MM-5v () scm ! kde ! org
[Download RAW message or body]
Git commit 01153b49cd55b6254c0e6e97a51d91188dd46a4d by Percy Camilo Triveño \
Aucahuasi. Committed on 15/02/2014 at 17:03.
Pushed by aucahuasi into branch 'master'.
REVIEW: 115439
M +7 -1 analitza/CMakeLists.txt
R +3 -3 analitza/abstractexpressionvisitor.cpp [from: \
analitza/expressionwriter.cpp - 088% similarity] R +20 -20 \
analitza/abstractexpressionvisitor.h [from: analitza/expressionwriter.h - 066% \
similarity] M +14 -14 analitza/analitzautils.cpp
M +3 -3 analitza/apply.cpp
M +1 -1 analitza/apply.h
M +3 -3 analitza/container.cpp
M +1 -1 analitza/container.h
M +3 -3 analitza/customobject.cpp
M +1 -1 analitza/customobject.h
M +4 -5 analitza/expression.cpp
M +31 -31 analitza/expressiontypechecker.cpp
M +14 -14 analitza/expressiontypechecker.h
M +31 -31 analitza/htmlexpressionwriter.cpp
M +15 -15 analitza/htmlexpressionwriter.h
M +3 -3 analitza/list.cpp
M +1 -1 analitza/list.h
M +23 -23 analitza/mathmlexpressionwriter.cpp
M +14 -14 analitza/mathmlexpressionwriter.h
M +29 -29 analitza/mathmlpresentationexpressionwriter.cpp
M +14 -14 analitza/mathmlpresentationexpressionwriter.h
M +5 -5 analitza/matrix.cpp
M +2 -2 analitza/matrix.h
M +1 -1 analitza/object.cpp
M +2 -2 analitza/object.h
M +3 -3 analitza/operator.cpp
M +1 -1 analitza/operator.h
M +21 -21 analitza/stringexpressionwriter.cpp
M +15 -15 analitza/stringexpressionwriter.h
M +3 -3 analitza/value.cpp
M +1 -1 analitza/value.h
M +3 -3 analitza/variable.cpp
M +1 -1 analitza/variable.h
M +3 -3 analitza/vector.cpp
M +1 -1 analitza/vector.h
http://commits.kde.org/analitza/01153b49cd55b6254c0e6e97a51d91188dd46a4d
diff --git a/analitza/CMakeLists.txt b/analitza/CMakeLists.txt
index af270b6..6315d32 100644
--- a/analitza/CMakeLists.txt
+++ b/analitza/CMakeLists.txt
@@ -10,7 +10,7 @@ set(analitza_SRCS
providederivative.cpp
abstractexpressiontransformer.cpp
expression.cpp
- expressionwriter.cpp
+ abstractexpressionvisitor.cpp
stringexpressionwriter.cpp
mathmlexpressionwriter.cpp
mathmlpresentationexpressionwriter.cpp
@@ -57,6 +57,7 @@ install(FILES
analyzer.h
analitzautils.h
expression.h
+ abstractexpressionvisitor.h
object.h
operations.h
operator.h
@@ -64,6 +65,11 @@ install(FILES
value.h
variables.h
vector.h
+ apply.h
+ list.h
+ customobject.h
+ container.h
+ matrix.h
expressiontype.h
builtinmethods.h
importqobjectmetatype.h
diff --git a/analitza/expressionwriter.cpp b/analitza/abstractexpressionvisitor.cpp
similarity index 88%
rename from analitza/expressionwriter.cpp
rename to analitza/abstractexpressionvisitor.cpp
index 8aff488..f9550a8 100644
--- a/analitza/expressionwriter.cpp
+++ b/analitza/abstractexpressionvisitor.cpp
@@ -1,5 +1,5 @@
/*************************************************************************************
- * Copyright (C) 2008 by Aleix Pol <aleixpol@kde.org> \
* + * Copyright (C) 2014 by Percy Camilo T. Aucahuasi <percy.camilo.ta@gmail.com> \
*
* \
*
* This program is free software; you can redistribute it and/or \
*
* modify it under the terms of the GNU General Public License \
* @@ -16,9 +16,9 @@
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA \
*
*************************************************************************************/
-#include "expressionwriter.h"
+#include "abstractexpressionvisitor.h"
using namespace Analitza;
-ExpressionWriter::~ExpressionWriter()
+AbstractExpressionVisitor::~AbstractExpressionVisitor()
{}
diff --git a/analitza/expressionwriter.h b/analitza/abstractexpressionvisitor.h
similarity index 66%
rename from analitza/expressionwriter.h
rename to analitza/abstractexpressionvisitor.h
index ea9c92d..20297b3 100644
--- a/analitza/expressionwriter.h
+++ b/analitza/abstractexpressionvisitor.h
@@ -1,5 +1,6 @@
/*************************************************************************************
* Copyright (C) 2008 by Aleix Pol <aleixpol@kde.org> \
* + * Copyright (C) 2014 by Percy Camilo T. Aucahuasi <percy.camilo.ta@gmail.com> \
*
* \
*
* This program is free software; you can redistribute it and/or \
*
* modify it under the terms of the GNU General Public License \
* @@ -16,16 +17,15 @@
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA \
*
*************************************************************************************/
-#ifndef EXPRESSIONWRITER_H
-#define EXPRESSIONWRITER_H
-
-#include <QString>
+#ifndef ABSTRACTEXPRESSIONVISITOR_H
+#define ABSTRACTEXPRESSIONVISITOR_H
#include "analitzaexport.h"
+#include <QVariant>
+
namespace Analitza
{
-
class Object;
class Apply;
class Ci;
@@ -39,30 +39,30 @@ class Matrix;
class MatrixRow;
/**
- * \class ExpressionWriter
+ * \class AbstractExpressionWriter
*
* \ingroup AnalitzaModule
*
- * \brief This class represents an expression writer.
+ * \brief This interface defines the generic expression writer contract.
*/
-class ANALITZA_EXPORT ExpressionWriter
+class ANALITZA_EXPORT AbstractExpressionVisitor
{
public:
- virtual ~ExpressionWriter();
+ virtual ~AbstractExpressionVisitor();
- virtual QString accept(const Operator* var) = 0;
- virtual QString accept(const Ci* var) = 0;
- virtual QString accept(const Cn* var) = 0;
- virtual QString accept(const Container* var) = 0;
- virtual QString accept(const Vector* var) = 0;
- virtual QString accept(const List* l) = 0;
- virtual QString accept(const Apply* a) = 0;
- virtual QString accept(const CustomObject* c) = 0;
- virtual QString accept(const Matrix* c) = 0;
- virtual QString accept(const MatrixRow* c) = 0;
+ virtual QVariant visit(const Operator* var) = 0;
+ virtual QVariant visit(const Ci* var) = 0;
+ virtual QVariant visit(const Cn* var) = 0;
+ virtual QVariant visit(const Container* var) = 0;
+ virtual QVariant visit(const Vector* var) = 0;
+ virtual QVariant visit(const List* l) = 0;
+ virtual QVariant visit(const Apply* a) = 0;
+ virtual QVariant visit(const CustomObject* c) = 0;
+ virtual QVariant visit(const Matrix* c) = 0;
+ virtual QVariant visit(const MatrixRow* c) = 0;
- virtual QString result() const=0;
+ virtual QVariant result() const = 0;
};
}
diff --git a/analitza/analitzautils.cpp b/analitza/analitzautils.cpp
index c38eeaa..4205310 100644
--- a/analitza/analitzautils.cpp
+++ b/analitza/analitzautils.cpp
@@ -18,7 +18,7 @@
#include "analitzautils.h"
-#include "expressionwriter.h"
+#include "abstractexpressionvisitor.h"
#include "vector.h"
#include "value.h"
#include "list.h"
@@ -280,14 +280,14 @@ bool hasVars(const Analitza::Object* o, const QStringList& \
bvars) return r;
}
-struct ObjectWalker : public ExpressionWriter
+struct ObjectWalker : public AbstractExpressionVisitor
{
ObjectWalker(const QByteArray& pref) : ind(0), m_prefix(pref) {}
- virtual QString accept(const Operator* root)
+ virtual QVariant visit(const Operator* root)
{ qDebug() << prefix().constData() << "| operator: " << root->toString(); return \
QString(); }
- virtual QString accept(const Ci* var)
+ virtual QVariant visit(const Ci* var)
{
QString value;
if(var->depth()>=0)
@@ -299,14 +299,14 @@ struct ObjectWalker : public ExpressionWriter
return QString();
}
- virtual QString accept(const Cn* num)
+ virtual QVariant visit(const Cn* num)
{ qDebug() << prefix().constData() << "| num: " << num->value() << " format: " << \
num->format(); return QString(); }
- virtual QString accept(const CustomObject* c)
+ virtual QVariant visit(const CustomObject* c)
{ qDebug() << prefix().constData() << "| custom " << c; return QString(); }
- virtual QString accept(const Container* c)
+ virtual QVariant visit(const Container* c)
{
qDebug() << prefix().constData() << "| cont: " << c->tagName();// << "=" << \
c->toString(); ind++;
@@ -316,7 +316,7 @@ struct ObjectWalker : public ExpressionWriter
return QString();
}
- virtual QString accept ( const Apply* c )
+ virtual QVariant visit(const Apply* c)
{
qDebug() << prefix().constData() << "| apply op:" << \
c->firstOperator().toString(); ind++;
@@ -330,7 +330,7 @@ struct ObjectWalker : public ExpressionWriter
return QString();
}
- virtual QString accept(const Vector* v)
+ virtual QVariant visit(const Vector* v)
{
qDebug() << prefix().constData() << "| vector: " << v->size();
ind++;
@@ -340,7 +340,7 @@ struct ObjectWalker : public ExpressionWriter
return QString();
}
- virtual QString accept(const List* v)
+ virtual QVariant visit(const List* v)
{
qDebug() << prefix().constData() << "| list: " << v->size();
ind++;
@@ -350,7 +350,7 @@ struct ObjectWalker : public ExpressionWriter
return QString();
}
- virtual QString accept(const Matrix* m) {
+ virtual QVariant visit(const Matrix* m) {
qDebug() << prefix().constData() << "| matrix: ";
ind++;
for(Matrix::const_iterator it=m->constBegin(); it!=m->constEnd(); ++it)
@@ -359,7 +359,7 @@ struct ObjectWalker : public ExpressionWriter
return QString();
}
- virtual QString accept(const MatrixRow* m) {
+ virtual QVariant visit(const MatrixRow* m) {
qDebug() << prefix().constData() << "| matrix: ";
ind++;
for(MatrixRow::const_iterator it=m->constBegin(); it!=m->constEnd(); ++it)
@@ -376,9 +376,9 @@ struct ObjectWalker : public ExpressionWriter
return ret;
}
- void visitNow(const Object* o) { if(o) o->visit(this); else qDebug() << \
prefix().constData() << "Null" ;} + void visitNow(const Object* o) { if(o) \
o->accept(this); else qDebug() << prefix().constData() << "Null" ;}
- QString result() const { return QString(); }
+ QVariant result() const { return QString(); }
int ind;
QByteArray m_prefix;
diff --git a/analitza/apply.cpp b/analitza/apply.cpp
index e787372..7812a0f 100644
--- a/analitza/apply.cpp
+++ b/analitza/apply.cpp
@@ -17,7 +17,7 @@
*************************************************************************************/
#include "apply.h"
-#include "expressionwriter.h"
+#include "abstractexpressionvisitor.h"
#include <QStringList>
#include "variable.h"
#include "analitzautils.h"
@@ -91,9 +91,9 @@ void Apply::prependBranch(Object* o)
m_params.prepend(o);
}
-QString Apply::visit(ExpressionWriter* exp) const
+QVariant Apply::accept(AbstractExpressionVisitor* exp) const
{
- return exp->accept(this);
+ return exp->visit(this);
}
QStringList Apply::bvarStrings() const
diff --git a/analitza/apply.h b/analitza/apply.h
index 84b09f5..260f3af 100644
--- a/analitza/apply.h
+++ b/analitza/apply.h
@@ -49,7 +49,7 @@ class ANALITZA_EXPORT Apply : public Object
virtual Apply* copy() const;
virtual bool matches(const Analitza::Object* exp, QMap< QString, const \
Analitza::Object* >* found) const;
- virtual QString visit(ExpressionWriter* exp) const;
+ virtual QVariant accept(AbstractExpressionVisitor* exp) const;
const Operator& firstOperator() const { return m_op; }
int countValues() const { return m_params.size(); }
diff --git a/analitza/container.cpp b/analitza/container.cpp
index aabd780..958d1d6 100644
--- a/analitza/container.cpp
+++ b/analitza/container.cpp
@@ -18,7 +18,7 @@
#include "container.h"
#include "expression.h"
-#include "expressionwriter.h"
+#include "abstractexpressionvisitor.h"
#include "vector.h"
#include "value.h"
#include "list.h"
@@ -76,9 +76,9 @@ Container* Container::copy() const
return new Container(*this);
}
-QString Container::visit(ExpressionWriter* e) const
+QVariant Container::accept(AbstractExpressionVisitor* e) const
{
- return e->accept(this);
+ return e->visit(this);
}
bool Container::isZero() const
diff --git a/analitza/container.h b/analitza/container.h
index f0deec6..1e30f46 100644
--- a/analitza/container.h
+++ b/analitza/container.h
@@ -119,7 +119,7 @@ public:
/** @return Returns the string associated to the container type. */
QString tagName() const;
- virtual QString visit(ExpressionWriter*) const;
+ virtual QVariant accept(AbstractExpressionVisitor*) const;
virtual bool isZero() const;
diff --git a/analitza/customobject.cpp b/analitza/customobject.cpp
index da8bdb9..abe4ee9 100644
--- a/analitza/customobject.cpp
+++ b/analitza/customobject.cpp
@@ -17,7 +17,7 @@
*************************************************************************************/
#include "customobject.h"
-#include "expressionwriter.h"
+#include "abstractexpressionvisitor.h"
using namespace Analitza;
@@ -58,7 +58,7 @@ bool CustomObject::operator==(const CustomObject& obj) const
return this==&obj || obj.m_value == m_value;
}
-QString CustomObject::visit(ExpressionWriter* exp) const
+QVariant CustomObject::accept(AbstractExpressionVisitor* exp) const
{
- return exp->accept(this);
+ return exp->visit(this);
}
diff --git a/analitza/customobject.h b/analitza/customobject.h
index b6f200c..e791354 100644
--- a/analitza/customobject.h
+++ b/analitza/customobject.h
@@ -45,7 +45,7 @@ class ANALITZA_EXPORT CustomObject : public Object
virtual Object* copy() const;
virtual bool matches(const Analitza::Object* exp, QMap< QString, const \
Analitza::Object* >* found) const;
- virtual QString visit(ExpressionWriter* exp) const;
+ virtual QVariant accept(AbstractExpressionVisitor* exp) const;
bool operator==(const CustomObject& obj) const;
QVariant value() const { return m_value; }
diff --git a/analitza/expression.cpp b/analitza/expression.cpp
index 48fd8d8..a78c6f2 100644
--- a/analitza/expression.cpp
+++ b/analitza/expression.cpp
@@ -25,7 +25,6 @@
#include "value.h"
#include "vector.h"
#include "variable.h"
-#include "expressionwriter.h"
#include "stringexpressionwriter.h"
#include "htmlexpressionwriter.h"
#include "mathmlexpressionwriter.h"
@@ -489,26 +488,26 @@ Object* Expression::ExpressionPrivate::branch(const \
QDomElement& elem) QString Expression::toHtml() const
{
Q_ASSERT(isCorrect());
- return HtmlExpressionWriter(d->m_tree).result();
+ return HtmlExpressionWriter(d->m_tree).result().toString();
}
QString Expression::toMathMLPresentation() const
{
Q_ASSERT(isCorrect());
- return MathMLPresentationExpressionWriter(d->m_tree).result();
+ return MathMLPresentationExpressionWriter(d->m_tree).result().toString();
}
QString Expression::toMathML() const
{
Q_ASSERT(isCorrect());
- return MathMLExpressionWriter(d->m_tree).result();
+ return MathMLExpressionWriter(d->m_tree).result().toString();
}
QString Expression::toString() const
{
Q_ASSERT(isCorrect());
StringExpressionWriter s(d->m_tree);
- return s.result();
+ return s.result().toString();
}
enum Object::ObjectType Expression::whatType(const QString& tag)
diff --git a/analitza/expressiontypechecker.cpp b/analitza/expressiontypechecker.cpp
index 8616127..4b2c778 100644
--- a/analitza/expressiontypechecker.cpp
+++ b/analitza/expressiontypechecker.cpp
@@ -79,13 +79,13 @@ ExpressionType ExpressionTypeChecker::check(const Expression& \
exp) m_stars=1;
current=ExpressionType(ExpressionType::Error);
- exp.tree()->visit(this);
+ exp.tree()->accept(this);
// qDebug() << "cheeeeeeck" << m_vars;
return current;
}
-QString ExpressionTypeChecker::accept(const Operator*) { Q_ASSERT(false && "should \
not get here"); return QString(); } +QVariant ExpressionTypeChecker::visit(const \
Operator*) { Q_ASSERT(false && "should not get here"); return QVariant(); }
bool ExpressionTypeChecker::inferType(const ExpressionType& found, const \
ExpressionType& targetType, QMap<QString, ExpressionType>* assumptions) {
@@ -142,7 +142,7 @@ ExpressionType ExpressionTypeChecker::solve(const Operator* o, \
const QVector< Ob
QList<ExpressionType> paramtypes;
for(QVector<Object*>::const_iterator it=parameters.constBegin(), \
itEnd=parameters.constEnd(); it!=itEnd; ++it) {
- (*it)->visit(this);
+ (*it)->accept(this);
paramtypes += current;
}
@@ -282,7 +282,7 @@ ExpressionType ExpressionTypeChecker::solve(const Operator* o, \
const QVector< Ob }
}
-QString ExpressionTypeChecker::accept(const Ci* var)
+QVariant ExpressionTypeChecker::visit(const Ci* var)
{
if(m_typeForBVar.contains(var->name())) {
current=m_typeForBVar.value(var->name());
@@ -305,7 +305,7 @@ bool ExpressionTypeChecker::isVariableDefined(const QString& id) \
const return m_v->contains(id) || m_vars.contains(id);
}
-QString ExpressionTypeChecker::accept(const Cn* c)
+QVariant ExpressionTypeChecker::visit(const Cn* c)
{
ExpressionType::Type type;
@@ -340,7 +340,7 @@ ExpressionType ExpressionTypeChecker::commonType(const \
QList<Object*>& values) if(values.isEmpty()) {
ret=ExpressionType(ExpressionType::Any, m_stars++);
} else foreach(const Object* o, values) {
- o->visit(this);
+ o->accept(this);
// qDebug()<< "sususu" << current << ret << "||" << current.assumptions() << \
ret.assumptions();
@@ -391,7 +391,7 @@ ExpressionType ExpressionTypeChecker::commonType(const \
QList<Object*>& values) return ret;
}
-QString ExpressionTypeChecker::accept(const Apply* c)
+QVariant ExpressionTypeChecker::visit(const Apply* c)
{
QMap<QString, ExpressionType> ctx=m_typeForBVar;
QMap<QString, ExpressionType> assumptions;
@@ -402,20 +402,20 @@ QString ExpressionTypeChecker::accept(const Apply* c)
ExpressionType tt;
if(ul) {
Object* dl=c->dlimit();
- ul->visit(this);
+ ul->accept(this);
tt=current; //FIXME: should remove when done
if(!current.isError() && current.type()!=ExpressionType::Any)
assumptions=typeIs(dl, ExpressionType(current));
else {
- dl->visit(this);
+ dl->accept(this);
tt=current;
if(!current.isError())
assumptions=typeIs(ul, ExpressionType(current));
}
} else if(c->domain()) {
- c->domain()->visit(this);
+ c->domain()->accept(this);
if(current.type()==ExpressionType::Any) {
ExpressionType anyItem(ExpressionType::Any, m_stars++);
@@ -449,7 +449,7 @@ QString ExpressionTypeChecker::accept(const Apply* c)
case Operator::none:
case Operator::sum:
case Operator::product:
- (*c->firstValue())->visit(this);
+ (*c->firstValue())->accept(this);
current.addAssumptions(assumptions);
break;
case Operator::diff:
@@ -461,7 +461,7 @@ QString ExpressionTypeChecker::accept(const Apply* c)
break;
case Operator::function: {
// qDebug() << "calling" << c->toString();
- c->m_params.first()->visit(this);
+ c->m_params.first()->accept(this);
// qDebug() << "retrieved lambda" << c->m_params.first()->toString() << current \
<< current.assumptions(); ExpressionType returned = current;
assumptions=current.assumptions();
@@ -469,7 +469,7 @@ QString ExpressionTypeChecker::accept(const Apply* c)
QList<ExpressionType> exps;
Apply::const_iterator it=c->firstValue()+1, itEnd=c->constEnd();
for(; it!=itEnd; ++it) {
- (*it)->visit(this);
+ (*it)->accept(this);
exps += current;
}
@@ -611,7 +611,7 @@ QString ExpressionTypeChecker::accept(const Apply* c)
return QString();
}
-QString ExpressionTypeChecker::accept(const CustomObject*)
+QVariant ExpressionTypeChecker::visit(const CustomObject*)
{
Q_ASSERT(false && "we shouldn't have to construct any custom object");
return QString();
@@ -644,7 +644,7 @@ ExpressionType ExpressionTypeChecker::tellTypeIdentity(const \
QString& name, cons
//1. Check if parameters are applied correctly
//2. Return the operator result type
-QString ExpressionTypeChecker::accept(const Container* c)
+QVariant ExpressionTypeChecker::visit(const Container* c)
{
// qDebug() << "XIUXIU" << c->toString();
switch(c->containerType()) {
@@ -682,7 +682,7 @@ QString ExpressionTypeChecker::accept(const Container* c)
} break;
case Container::piece: {
QMap<QString, ExpressionType> assumptions=typeIs(c->m_params.last(), \
ExpressionType(ExpressionType::Bool)); //condition check
- c->m_params.first()->visit(this); //we return the body
+ c->m_params.first()->accept(this); //we return the body
QList<ExpressionType> alts=current.type()==ExpressionType::Many ? \
current.alternatives() : QList<ExpressionType>() << current, rets; foreach(const \
ExpressionType& t, alts) { QMap<int, ExpressionType> stars;
@@ -704,7 +704,7 @@ QString ExpressionTypeChecker::accept(const Container* c)
Ci* var = static_cast<Ci*>(c->m_params.first());
m_calculating.append(var->name());
- c->m_params.last()->visit(this);
+ c->m_params.last()->accept(this);
m_calculating.removeLast();
current=tellTypeIdentity(var->name(), current);
@@ -713,7 +713,7 @@ QString ExpressionTypeChecker::accept(const Container* c)
QSet<QString> aux=m_lambdascope;
QStringList bvars=c->bvarStrings();
m_lambdascope+=bvars.toSet();
- c->m_params.last()->visit(this);
+ c->m_params.last()->accept(this);
m_lambdascope=aux;
QMap<QString, ExpressionType> assumptions=current.assumptions();
@@ -750,7 +750,7 @@ QString ExpressionTypeChecker::accept(const Container* c)
// for(Container::const_iterator it=c->constBegin(); it!=c->constEnd(); ++it)
// Q_ASSERT(c->constBegin()+1==c->constEnd());
if(c->constBegin()+1==c->constEnd())
- (*c->constBegin())->visit(this);
+ (*c->constBegin())->accept(this);
break;
}
@@ -765,7 +765,7 @@ QString ExpressionTypeChecker::accept(const Container* c)
}
template <class T>
-QString ExpressionTypeChecker::acceptListOrVector(const T* v, ExpressionType::Type \
t, int size) +QVariant ExpressionTypeChecker::visitListOrVector(const T* v, \
ExpressionType::Type t, int size) {
ExpressionType cont=commonType(v->values());
@@ -792,27 +792,27 @@ QString ExpressionTypeChecker::acceptListOrVector(const T* v, \
ExpressionType::Ty return QString();
}
-QString ExpressionTypeChecker::accept(const List* l)
+QVariant ExpressionTypeChecker::visit(const List* l)
{
- acceptListOrVector(l, ExpressionType::List, 0);
+ visitListOrVector(l, ExpressionType::List, 0);
return QString();
}
-QString ExpressionTypeChecker::accept(const Vector* l)
+QVariant ExpressionTypeChecker::visit(const Vector* l)
{
- acceptListOrVector(l, ExpressionType::Vector, l->size());
+ visitListOrVector(l, ExpressionType::Vector, l->size());
return QString();
}
-QString ExpressionTypeChecker::accept(const Matrix* m)
+QVariant ExpressionTypeChecker::visit(const Matrix* m)
{
- acceptListOrVector(m, ExpressionType::Matrix, m->size());
+ visitListOrVector(m, ExpressionType::Matrix, m->size());
return QString();
}
-QString ExpressionTypeChecker::accept(const MatrixRow* mr)
+QVariant ExpressionTypeChecker::visit(const MatrixRow* mr)
{
- acceptListOrVector(mr, ExpressionType::Vector, mr->size());
+ visitListOrVector(mr, ExpressionType::Vector, mr->size());
return QString();
}
@@ -821,7 +821,7 @@ QMap<QString, ExpressionType> ExpressionTypeChecker::typeIs(T it, \
const T& itEnd {
QList<ExpressionType> types;
for(; it!=itEnd; ++it) {
- (*it)->visit(this);
+ (*it)->accept(this);
types+=current;
}
types=ExpressionType::manyFromArgs(types);
@@ -849,7 +849,7 @@ QMap<QString, ExpressionType> ExpressionTypeChecker::typeIs(T it, \
const T& itEnd
QMap<QString, ExpressionType> ExpressionTypeChecker::typeIs(const Object* o, const \
ExpressionType& type) {
- o->visit(this);
+ o->accept(this);
// qDebug() << "fluuuu" << current << type;
bool corr=false;
@@ -879,7 +879,7 @@ ExpressionType ExpressionTypeChecker::typeForVar(const QString& \
var) // qDebug() << "checking..." << var;
Q_ASSERT(m_v->contains(var));
m_calculating += var;
- m_v->value(var)->visit(this);
+ m_v->value(var)->accept(this);
m_calculating.removeLast();
current=tellTypeIdentity(var, current);
current.clearAssumptions();
diff --git a/analitza/expressiontypechecker.h b/analitza/expressiontypechecker.h
index 8263c2b..c203596 100644
--- a/analitza/expressiontypechecker.h
+++ b/analitza/expressiontypechecker.h
@@ -19,7 +19,7 @@
#ifndef EXPRESSIONTYPECHECKER_H
#define EXPRESSIONTYPECHECKER_H
-#include "expressionwriter.h"
+#include "abstractexpressionvisitor.h"
#include "analitzaexport.h"
#include "expressiontype.h"
#include <QStack>
@@ -31,25 +31,25 @@ namespace Analitza
class Variables;
class Expression;
-class ANALITZA_EXPORT ExpressionTypeChecker : public ExpressionWriter
+class ANALITZA_EXPORT ExpressionTypeChecker : public AbstractExpressionVisitor
{
public:
ExpressionTypeChecker(Variables* v);
ExpressionType check(const Expression& exp);
- virtual QString accept(const Operator* var);
- virtual QString accept(const Ci* var);
- virtual QString accept(const Cn* var);
- virtual QString accept(const Container* var);
- virtual QString accept(const Vector* var);
- virtual QString accept(const List* l);
- virtual QString accept(const Matrix* c);
- virtual QString accept(const Analitza::MatrixRow* m);
- virtual QString accept(const Apply* a);
- virtual QString accept(const CustomObject* c);
+ virtual QVariant visit(const Operator* var);
+ virtual QVariant visit(const Ci* var);
+ virtual QVariant visit(const Cn* var);
+ virtual QVariant visit(const Container* var);
+ virtual QVariant visit(const Vector* var);
+ virtual QVariant visit(const List* l);
+ virtual QVariant visit(const Matrix* c);
+ virtual QVariant visit(const Analitza::MatrixRow* m);
+ virtual QVariant visit(const Apply* a);
+ virtual QVariant visit(const CustomObject* c);
- virtual QString result() const { return QString(); }
+ virtual QVariant result() const { return QVariant(); }
QStringList dependencies() const { return m_deps; }
bool hasDependencies() const { return !m_deps.isEmpty(); }
@@ -70,7 +70,7 @@ class ANALITZA_EXPORT ExpressionTypeChecker : public \
ExpressionWriter QMap<QString, ExpressionType> typeIs(T it, const T& itEnd, const \
ExpressionType& type);
template <class T>
- QString acceptListOrVector(const T* v, ExpressionType::Type t, int size);
+ QVariant visitListOrVector(const T* v, ExpressionType::Type t, int size);
ExpressionType typeForVar(const QString& var);
diff --git a/analitza/htmlexpressionwriter.cpp b/analitza/htmlexpressionwriter.cpp
index cf7d4a0..87db178 100644
--- a/analitza/htmlexpressionwriter.cpp
+++ b/analitza/htmlexpressionwriter.cpp
@@ -36,11 +36,11 @@ using namespace Analitza;
QMap<Operator::OperatorType, QString> initOperators();
template <class T>
-QStringList HtmlExpressionWriter::allValues(T it, const T& itEnd, ExpressionWriter* \
writer) +QStringList HtmlExpressionWriter::allValues(T it, const T& itEnd, \
AbstractExpressionVisitor* writer) {
QStringList elements;
for(; it!=itEnd; ++it)
- elements += (*it)->visit(writer);
+ elements += (*it)->accept(writer).toString();
return elements;
}
@@ -55,51 +55,51 @@ QString keyword(const QString& op) { return i18nc("html \
representation of an ope HtmlExpressionWriter::HtmlExpressionWriter(const Object* o)
{
if(o)
- m_result=o->visit(this);
+ m_result=o->accept(this);
}
-QString HtmlExpressionWriter::accept(const Vector* vec)
+QVariant HtmlExpressionWriter::visit(const Vector* vec)
{
- return keyword("vector ")+oper("{ \
")+allValues<Vector::const_iterator>(vec->constBegin(), vec->constEnd(), \
this).join(QString(oper(", ")))+oper(" }"); + return QString(keyword("vector \
")+oper("{ ")+allValues<Vector::const_iterator>(vec->constBegin(), vec->constEnd(), \
this).join(QString(oper(", ")))+oper(" }")); }
-QString HtmlExpressionWriter::accept(const Matrix* m)
+QVariant HtmlExpressionWriter::visit(const Matrix* m)
{
- return keyword("matrix ")+oper("{ ")+allValues(m->constBegin(), m->constEnd(), \
this).join(QString(oper(", ")))+oper(" }"); + return QString(keyword("matrix \
")+oper("{ ")+allValues(m->constBegin(), m->constEnd(), this).join(QString(oper(", \
")))+oper(" }")); }
-QString HtmlExpressionWriter::accept(const MatrixRow* mr)
+QVariant HtmlExpressionWriter::visit(const MatrixRow* mr)
{
- return keyword("matrixrow ")+oper("{ ")+allValues(mr->constBegin(), mr->constEnd(), \
this).join(QString(oper(", ")))+oper(" }"); + return QString(keyword("matrixrow \
")+oper("{ ")+allValues(mr->constBegin(), mr->constEnd(), this).join(QString(oper(", \
")))+oper(" }")); }
-QString HtmlExpressionWriter::accept(const List* vec)
+QVariant HtmlExpressionWriter::visit(const List* vec)
{
if(!vec->isEmpty() && vec->at(0)->type()==Object::value && \
static_cast<Cn*>(vec->at(0))->format()==Cn::Char) {
- return "<span class='string'>""+AnalitzaUtils::listToString(vec)+ \
""</span>"; + return QString("<span \
class='string'>""+AnalitzaUtils::listToString(vec)+ ""</span>"); } else
- return keyword("list ")+oper("{ \
")+allValues<List::const_iterator>(vec->constBegin(), vec->constEnd(), \
this).join(QString(oper(", ")))+oper(" }"); + return QString((keyword("list \
")+oper("{ ")+allValues<List::const_iterator>(vec->constBegin(), vec->constEnd(), \
this).join(QString(oper(", ")))+oper(" }"))); }
-QString HtmlExpressionWriter::accept(const Cn* var)
+QVariant HtmlExpressionWriter::visit(const Cn* var)
{
if(var->isBoolean())
- return "<span class='var'>"+QString(var->isTrue() ? "true" : "false")+"</span>";
+ return QString("<span class='var'>"+QString(var->isTrue() ? "true" : \
"false")+"</span>"); else
- return "<span class='num'>"+QString::number(var->value(), 'g', 12)+"</span>";
+ return QString("<span class='num'>"+QString::number(var->value(), 'g', \
12)+"</span>"); }
-QString HtmlExpressionWriter::accept(const Analitza::Ci* var)
+QVariant HtmlExpressionWriter::visit(const Analitza::Ci* var)
{
return var->toHtml();
}
-QString HtmlExpressionWriter::accept(const Analitza::Operator* o)
+QVariant HtmlExpressionWriter::visit(const Analitza::Operator* o)
{
- return "<span class='func'>"+o->toString()+"</span>";
+ return QString("<span class='func'>"+o->toString()+"</span>");
}
-QString HtmlExpressionWriter::accept ( const Analitza::Apply* a )
+QVariant HtmlExpressionWriter::visit ( const Analitza::Apply* a )
{
Operator op=a->firstOperator();
QStringList ret;
@@ -109,13 +109,13 @@ QString HtmlExpressionWriter::accept ( const Analitza::Apply* a \
) if(a->ulimit() || a->dlimit()) {
bounds += oper('=');
if(a->dlimit())
- bounds += a->dlimit()->visit(this);
+ bounds += a->dlimit()->accept(this).toString();
bounds += oper("..");
if(a->ulimit())
- bounds += a->ulimit()->visit(this);
+ bounds += a->ulimit()->accept(this).toString();
}
else if(a->domain())
- bounds += oper('@')+a->domain()->visit(this);
+ bounds += oper('@')+a->domain()->accept(this).toString();
int i = 0;
foreach(Object* o, a->m_params) {
@@ -125,11 +125,11 @@ QString HtmlExpressionWriter::accept ( const Analitza::Apply* a \
) Q_ASSERT(false);
break;
case Object::variable:
- ret << static_cast<const Ci*>(o)->visit(this);
+ ret << static_cast<const Ci*>(o)->accept(this).toString();
break;
case Object::apply: {
Apply *c = (Apply*) o;
- QString s = c->visit(this);
+ QString s = c->accept(this).toString();
if(s_operators.contains(op.operatorType())) {
Operator child_op = c->firstOperator();
@@ -140,7 +140,7 @@ QString HtmlExpressionWriter::accept ( const Analitza::Apply* a )
ret << s;
} break;
default:
- ret << o->visit(this);
+ ret << o->accept(this).toString();
break;
}
++i;
@@ -169,7 +169,7 @@ QString HtmlExpressionWriter::accept ( const Analitza::Apply* a )
QString bounding;
QStringList bvars;
foreach(const Ci* bvar, a->bvarCi())
- bvars += bvar->visit(this);
+ bvars += bvar->accept(this).toString();
if(!bounds.isEmpty() || !bvars.isEmpty()) {
if(bvars.count()!=1) bounding +=oper('(');
@@ -179,13 +179,13 @@ QString HtmlExpressionWriter::accept ( const Analitza::Apply* a \
) bounding = ':'+bounding +bounds;
}
- toret += op.visit(this)+oper('(')+ret.join(oper(", "))+bounding+oper(')');
+ toret += op.accept(this).toString()+oper('(')+ret.join(oper(", \
"))+bounding+oper(')'); }
return toret;
}
-QString HtmlExpressionWriter::accept(const Container* var)
+QVariant HtmlExpressionWriter::visit(const Container* var)
{
QStringList ret = allValues(var->constBegin(), var->constEnd(), this);
@@ -199,7 +199,7 @@ QString HtmlExpressionWriter::accept(const Container* var)
QString last=ret.takeLast();
QStringList bvars;
foreach(const Ci* bvar, var->bvarCi())
- bvars += bvar->visit(this);
+ bvars += bvar->accept(this).toString();
if(bvars.count()!=1) toret +=oper('(');
toret += bvars.join(", ");
@@ -230,7 +230,7 @@ QString HtmlExpressionWriter::accept(const Container* var)
return toret;
}
-QString HtmlExpressionWriter::accept(const CustomObject*)
+QVariant HtmlExpressionWriter::visit(const CustomObject*)
{
- return "Custom Object";
+ return QString("Custom Object");
}
diff --git a/analitza/htmlexpressionwriter.h b/analitza/htmlexpressionwriter.h
index f8d0060..0b2660c 100644
--- a/analitza/htmlexpressionwriter.h
+++ b/analitza/htmlexpressionwriter.h
@@ -19,7 +19,7 @@
#ifndef HTMLEXPRESSIONWRITER_H
#define HTMLEXPRESSIONWRITER_H
-#include "expressionwriter.h"
+#include "abstractexpressionvisitor.h"
namespace Analitza
{
@@ -32,28 +32,28 @@ namespace Analitza
* \brief This class represents the string expression writer.
*/
-class HtmlExpressionWriter : public ExpressionWriter
+class HtmlExpressionWriter : public AbstractExpressionVisitor
{
public:
HtmlExpressionWriter(const Object* o);
- virtual QString accept(const Ci* var);
- virtual QString accept(const Cn* var);
- virtual QString accept(const Container* var);
- virtual QString accept(const Operator* var);
- virtual QString accept(const Vector* var);
- virtual QString accept(const List* l);
- virtual QString accept(const Apply* a);
- virtual QString accept(const CustomObject* c);
- virtual QString accept(const Matrix* c);
- virtual QString accept(const MatrixRow* c);
+ virtual QVariant visit(const Ci* var);
+ virtual QVariant visit(const Cn* var);
+ virtual QVariant visit(const Container* var);
+ virtual QVariant visit(const Operator* var);
+ virtual QVariant visit(const Vector* var);
+ virtual QVariant visit(const List* l);
+ virtual QVariant visit(const Apply* a);
+ virtual QVariant visit(const CustomObject* c);
+ virtual QVariant visit(const Matrix* c);
+ virtual QVariant visit(const MatrixRow* c);
- QString result() const { return m_result; }
+ QVariant result() const { return m_result; }
private:
template <class T>
- static QStringList allValues(T it, const T& itEnd, ExpressionWriter* writer);
- QString m_result;
+ static QStringList allValues(T it, const T& itEnd, AbstractExpressionVisitor* \
writer); + QVariant m_result;
};
}
diff --git a/analitza/list.cpp b/analitza/list.cpp
index fd1e411..966f919 100644
--- a/analitza/list.cpp
+++ b/analitza/list.cpp
@@ -18,7 +18,7 @@
#include "list.h"
#include "expression.h"
-#include "expressionwriter.h"
+#include "abstractexpressionvisitor.h"
#include "analitzautils.h"
using namespace Analitza;
@@ -55,9 +55,9 @@ void List::appendBranch(Object* o)
m_elements.append(o);
}
-QString List::visit(ExpressionWriter* e) const
+QVariant List::accept(AbstractExpressionVisitor* e) const
{
- return e->accept(this);
+ return e->visit(this);
}
bool List::isZero() const
diff --git a/analitza/list.h b/analitza/list.h
index 9719f9e..2781cc0 100644
--- a/analitza/list.h
+++ b/analitza/list.h
@@ -55,7 +55,7 @@ class ANALITZA_EXPORT List : public Object
void setAt(int i, Object* o) { m_elements[i]=o; }
QList<Object*> values() const { return m_elements; }
- virtual QString visit (ExpressionWriter* e) const;
+ virtual QVariant accept(AbstractExpressionVisitor* e) const;
virtual bool isZero() const;
virtual bool matches(const Object* pattern, QMap< QString, const Object* >* found) \
const;
diff --git a/analitza/mathmlexpressionwriter.cpp \
b/analitza/mathmlexpressionwriter.cpp index b70a1ca..065c013 100644
--- a/analitza/mathmlexpressionwriter.cpp
+++ b/analitza/mathmlexpressionwriter.cpp
@@ -33,18 +33,18 @@ using namespace Analitza;
MathMLExpressionWriter::MathMLExpressionWriter(const Object* o)
{
- m_result=o->visit(this);
+ m_result=o->accept(this);
}
-QString MathMLExpressionWriter::accept(const Ci* var)
+QVariant MathMLExpressionWriter::visit(const Ci* var)
{
QString attrib;
if(var->isFunction())
attrib=" type='function'";
- return "<ci"+attrib+'>'+var->name()+"</ci>";
+ return QString("<ci"+attrib+'>'+var->name()+"</ci>");
}
-QString MathMLExpressionWriter::accept(const Operator* op)
+QVariant MathMLExpressionWriter::visit(const Operator* op)
{
if(op->operatorType()==Operator::function)
return QString();
@@ -52,7 +52,7 @@ QString MathMLExpressionWriter::accept(const Operator* op)
return QString("<%1 />").arg(op->name());
}
-QString MathMLExpressionWriter::accept(const Cn* val)
+QVariant MathMLExpressionWriter::visit(const Cn* val)
{
if(val->isBoolean()) {
if(val->isTrue())
@@ -68,37 +68,37 @@ QString MathMLExpressionWriter::accept(const Cn* val)
}
}
-QString MathMLExpressionWriter::accept(const Vector* vec)
+QVariant MathMLExpressionWriter::visit(const Vector* vec)
{
QStringList elements;
for(Vector::const_iterator it=vec->constBegin(); it!=vec->constEnd(); ++it)
{
- elements += (*it)->visit(this);
+ elements += (*it)->accept(this).toString();
}
return QString("<vector>%1</vector>").arg(elements.join(QString()));
}
-QString MathMLExpressionWriter::accept(const Matrix* m)
+QVariant MathMLExpressionWriter::visit(const Matrix* m)
{
QStringList elements;
for(Matrix::const_iterator it=m->constBegin(); it!=m->constEnd(); ++it)
{
- elements += (*it)->visit(this);
+ elements += (*it)->accept(this).toString();
}
return QString("<matrix>%1</matrix>").arg(elements.join(QString()));
}
-QString MathMLExpressionWriter::accept(const MatrixRow* mr)
+QVariant MathMLExpressionWriter::visit(const MatrixRow* mr)
{
QStringList elements;
for(Matrix::const_iterator it=mr->constBegin(); it!=mr->constEnd(); ++it)
{
- elements += (*it)->visit(this);
+ elements += (*it)->accept(this).toString();
}
return QString("<matrixrow>%1</matrixrow>").arg(elements.join(QString()));
}
-QString MathMLExpressionWriter::accept(const List* vec)
+QVariant MathMLExpressionWriter::visit(const List* vec)
{
QStringList elements;
if(vec->size()==0)
@@ -110,39 +110,39 @@ QString MathMLExpressionWriter::accept(const List* vec)
return ret;
} else {
for(List::const_iterator it=vec->constBegin(); it!=vec->constEnd(); ++it)
- elements += (*it)->visit(this);
+ elements += (*it)->accept(this).toString();
return QString("<list>%1</list>").arg(elements.join(QString()));
}
}
-QString MathMLExpressionWriter::accept(const Container* c)
+QVariant MathMLExpressionWriter::visit(const Container* c)
{
QString ret;
foreach(const Object* o, c->m_params)
- ret += o->visit(this);
+ ret += o->accept(this).toString();
return QString("<%1>%2</%1>").arg(c->tagName()).arg(ret);
}
-QString MathMLExpressionWriter::accept(const Apply* a)
+QVariant MathMLExpressionWriter::visit(const Apply* a)
{
QString ret;
- ret += a->firstOperator().visit(this);
+ ret += a->firstOperator().accept(this).toString();
foreach(const Ci* bvar, a->bvarCi())
- ret += "<bvar>"+bvar->visit(this)+"</bvar>";
- if(a->ulimit()) ret += "<uplimit>"+a->ulimit()->visit(this)+"</uplimit>";
- if(a->dlimit()) ret += "<downlimit>"+a->dlimit()->visit(this)+"</downlimit>";
- if(a->domain()) ret += \
"<domainofapplication>"+a->domain()->visit(this)+"</domainofapplication>"; + ret += \
"<bvar>"+bvar->accept(this).toString()+"</bvar>"; + if(a->ulimit()) ret += \
"<uplimit>"+a->ulimit()->accept(this).toString()+"</uplimit>"; + if(a->dlimit()) ret \
+= "<downlimit>"+a->dlimit()->accept(this).toString()+"</downlimit>"; \
+ if(a->domain()) ret += \
"<domainofapplication>"+a->domain()->accept(this).toString()+"</domainofapplication>";
foreach(const Object* o, a->m_params)
- ret += o->visit(this);
+ ret += o->accept(this).toString();
return QString("<apply>%1</apply>").arg(ret);
}
-QString MathMLExpressionWriter::accept(const Analitza::CustomObject*)
+QVariant MathMLExpressionWriter::visit(const Analitza::CustomObject*)
{
return "<!-- custom object -->";
}
diff --git a/analitza/mathmlexpressionwriter.h b/analitza/mathmlexpressionwriter.h
index 70b08ae..cf22d16 100644
--- a/analitza/mathmlexpressionwriter.h
+++ b/analitza/mathmlexpressionwriter.h
@@ -19,7 +19,7 @@
#ifndef MATHMLEXPRESSIONWRITER_H
#define MATHMLEXPRESSIONWRITER_H
-#include "expressionwriter.h"
+#include "abstractexpressionvisitor.h"
namespace Analitza
{
@@ -32,26 +32,26 @@ namespace Analitza
* \brief This class represents the mathml expression writer.
*/
-class MathMLExpressionWriter : public ExpressionWriter
+class MathMLExpressionWriter : public AbstractExpressionVisitor
{
public:
MathMLExpressionWriter(const Object* o);
- virtual QString accept(const Ci* var);
- virtual QString accept(const Cn* var);
- virtual QString accept(const Container* var);
- virtual QString accept(const Operator* var);
- virtual QString accept(const Vector* var);
- virtual QString accept(const List* l);
- virtual QString accept(const Matrix* c);
- virtual QString accept(const MatrixRow* c);
- virtual QString accept(const Apply* a);
- virtual QString accept(const CustomObject* c);
+ virtual QVariant visit(const Ci* var);
+ virtual QVariant visit(const Cn* var);
+ virtual QVariant visit(const Container* var);
+ virtual QVariant visit(const Operator* var);
+ virtual QVariant visit(const Vector* var);
+ virtual QVariant visit(const List* l);
+ virtual QVariant visit(const Matrix* c);
+ virtual QVariant visit(const MatrixRow* c);
+ virtual QVariant visit(const Apply* a);
+ virtual QVariant visit(const CustomObject* c);
- QString result() const { return m_result; }
+ QVariant result() const { return m_result; }
private:
- QString m_result;
+ QVariant m_result;
};
}
diff --git a/analitza/mathmlpresentationexpressionwriter.cpp \
b/analitza/mathmlpresentationexpressionwriter.cpp index 3efc35b..614de7d 100644
--- a/analitza/mathmlpresentationexpressionwriter.cpp
+++ b/analitza/mathmlpresentationexpressionwriter.cpp
@@ -38,7 +38,7 @@ QStringList convertElements(T it, const T& itEnd, \
MathMLPresentationExpressionWr {
QStringList elems;
for(; it!=itEnd; ++it) {
- elems += (*it)->visit(w);
+ elems += (*it)->accept(w).toString();
}
return elems;
}
@@ -98,7 +98,7 @@ QString root(const Apply* c, MathMLPresentationExpressionWriter* w)
{
Cn two(2);
if(AnalitzaUtils::equalTree(c->values()[1], &two))
- return "<msqrt>"+(*c->firstValue())->visit(w)+"</msqrt>";
+ return "<msqrt>"+(*c->firstValue())->accept(w).toString()+"</msqrt>";
else
return "<mroot>"+convertElements<Apply::const_iterator>(c->firstValue(), \
c->constEnd(), w).join(QString())+"</mroot>"; }
@@ -140,9 +140,9 @@ QString function(const Apply* c, \
MathMLPresentationExpressionWriter* w) {
QString ret="<mrow>";
foreach(const Ci* bvar, c->bvarCi())
- ret+=bvar->visit(w);
+ ret+=bvar->accept(w).toString();
foreach(const Object* o, c->values())
- ret+=o->visit(w);
+ ret+=o->accept(w).toString();
ret+="</mrow>";
return ret;
}
@@ -188,20 +188,20 @@ MathMLPresentationExpressionWriter::operatorToString
MathMLPresentationExpressionWriter::MathMLPresentationExpressionWriter(const Object* \
o) {
- m_result=o->visit(this);
+ m_result=o->accept(this);
}
-QString MathMLPresentationExpressionWriter::accept(const Ci* var)
+QVariant MathMLPresentationExpressionWriter::visit(const Ci* var)
{
- return "<mi>"+var->name()+"</mi>";
+ return QString("<mi>"+var->name()+"</mi>");
}
-QString MathMLPresentationExpressionWriter::accept(const Operator* op)
+QVariant MathMLPresentationExpressionWriter::visit(const Operator* op)
{
return op->name();
}
-QString MathMLPresentationExpressionWriter::accept(const Cn* val)
+QVariant MathMLPresentationExpressionWriter::visit(const Cn* val)
{
if(val->isBoolean()) {
if(val->isTrue())
@@ -224,17 +224,17 @@ QString piecewise(const Container* c, \
MathMLPresentationExpressionWriter* w) if(piece->containerType()==Container::piece) \
{ ret += "<mtr>"
"<mtd>"
- +piece->m_params.first()->visit(w)+
+ +piece->m_params.first()->accept(w).toString()+
"</mtd>"
"<mtd>"
"<mtext>if </mtext>"
- +piece->m_params.last()->visit(w)+
+ +piece->m_params.last()->accept(w).toString()+
"</mtd>"
"</mtr>";
} else {
ret += "<mtr>"
"<mtd>"
- +piece->m_params.first()->visit(w)+
+ +piece->m_params.first()->accept(w).toString()+
"</mtd>"
"<mtd>"
"<mtext>otherwise</mtext>"
@@ -251,14 +251,14 @@ QString lambda(const Container* c, \
MathMLPresentationExpressionWriter* w) {
QString ret="<mrow>";
foreach(const Ci* bvar, c->bvarCi())
- ret+=bvar->visit(w);
+ ret+=bvar->accept(w).toString();
ret+="<mo>→</mo>";
- ret+=c->m_params.last()->visit(w);
+ ret+=c->m_params.last()->accept(w).toString();
ret+="</mrow>";
return ret;
}
-QString MathMLPresentationExpressionWriter::accept(const Container* c)
+QVariant MathMLPresentationExpressionWriter::visit(const Container* c)
{
QString ret;
// objectWalker(c);
@@ -291,27 +291,27 @@ QString MathMLPresentationExpressionWriter::accept(const \
Container* c) return ret;
}
-QString MathMLPresentationExpressionWriter::accept(const Vector* var)
+QVariant MathMLPresentationExpressionWriter::visit(const Vector* var)
{
- return "<mrow><mo><</mo>"+convertElements(var->constBegin(), var->constEnd(), \
this).join("<mo>,</mo>")+"<mo>></mo></mrow>"; + return \
QString("<mrow><mo><</mo>"+convertElements(var->constBegin(), var->constEnd(), \
this).join("<mo>,</mo>")+"<mo>></mo></mrow>"); }
-QString MathMLPresentationExpressionWriter::accept(const List* var)
+QVariant MathMLPresentationExpressionWriter::visit(const List* var)
{
- return "<mrow><mo>[</mo>"+convertElements(var->constBegin(), var->constEnd(), \
this).join("<mo>,</mo>")+"<mo>]</mo></mrow>"; + return \
QString("<mrow><mo>[</mo>"+convertElements(var->constBegin(), var->constEnd(), \
this).join("<mo>,</mo>")+"<mo>]</mo></mrow>"); }
-QString MathMLPresentationExpressionWriter::accept(const Matrix* m)
+QVariant MathMLPresentationExpressionWriter::visit(const Matrix* m)
{
- return "<mrow><mo>[</mo>"+convertElements(m->constBegin(), m->constEnd(), \
this).join("<mo>,</mo>")+"<mo>]</mo></mrow>"; + return \
QString("<mrow><mo>[</mo>"+convertElements(m->constBegin(), m->constEnd(), \
this).join("<mo>,</mo>")+"<mo>]</mo></mrow>"); }
-QString MathMLPresentationExpressionWriter::accept(const MatrixRow* m)
+QVariant MathMLPresentationExpressionWriter::visit(const MatrixRow* m)
{
- return "<mrow><mo>[</mo>"+convertElements(m->constBegin(), m->constEnd(), \
this).join("<mo>,</mo>")+"<mo>]</mo></mrow>"; + return \
QString("<mrow><mo>[</mo>"+convertElements(m->constBegin(), m->constEnd(), \
this).join("<mo>,</mo>")+"<mo>]</mo></mrow>"); }
-QString Analitza::MathMLPresentationExpressionWriter::accept ( const \
Analitza::Apply* a ) +QVariant \
Analitza::MathMLPresentationExpressionWriter::visit(const Analitza::Apply* a) {
QString ret;
Operator op=a->firstOperator();
@@ -329,11 +329,11 @@ QString Analitza::MathMLPresentationExpressionWriter::accept ( \
const Analitza::A const Object *ul=a->ulimit(), *dl=a->dlimit();
if(ul || dl) {
bvars += "<mo>=</mo>";
- if(dl) bvars += dl->visit(this);
+ if(dl) bvars += dl->accept(this).toString();
bvars += "<mo>..</mo>";
- if(ul) bvars += ul->visit(this);
+ if(ul) bvars += ul->accept(this).toString();
} else if(a->domain())
- bvars += "<mo>@</mo>" + a->domain()->visit(this);
+ bvars += "<mo>@</mo>" + a->domain()->accept(this).toString();
bvars="<mo>:</mo>"+bvars;
}
@@ -347,7 +347,7 @@ QString Analitza::MathMLPresentationExpressionWriter::accept ( \
const Analitza::A return ret;
}
-QString MathMLPresentationExpressionWriter::accept(const CustomObject*)
+QVariant MathMLPresentationExpressionWriter::visit(const CustomObject*)
{
- return "<!-- custom object -->";
+ return QString("<!-- custom object -->");
}
diff --git a/analitza/mathmlpresentationexpressionwriter.h \
b/analitza/mathmlpresentationexpressionwriter.h index 6c6419e..50218be 100644
--- a/analitza/mathmlpresentationexpressionwriter.h
+++ b/analitza/mathmlpresentationexpressionwriter.h
@@ -19,7 +19,7 @@
#ifndef MATHMLPRESENTATIONEXPRESSIONWRITER_H
#define MATHMLPRESENTATIONEXPRESSIONWRITER_H
-#include "expressionwriter.h"
+#include "abstractexpressionvisitor.h"
#include <QMap>
#include "operator.h"
@@ -34,27 +34,27 @@ namespace Analitza
* \brief This class represents the mathml expression writer.
*/
-class MathMLPresentationExpressionWriter : public ExpressionWriter
+class MathMLPresentationExpressionWriter : public AbstractExpressionVisitor
{
public:
typedef QString (*operatorToString)(const Apply* o, \
MathMLPresentationExpressionWriter* w); MathMLPresentationExpressionWriter(const \
Object* o);
- virtual QString accept(const Ci* var);
- virtual QString accept(const Cn* var);
- virtual QString accept(const Container* var);
- virtual QString accept(const Operator* var);
- virtual QString accept(const Vector* var);
- virtual QString accept(const List* l);
- virtual QString accept(const Matrix* m);
- virtual QString accept(const MatrixRow* c);
- virtual QString accept(const Apply* a);
- virtual QString accept(const CustomObject* c);
+ virtual QVariant visit(const Ci* var);
+ virtual QVariant visit(const Cn* var);
+ virtual QVariant visit(const Container* var);
+ virtual QVariant visit(const Operator* var);
+ virtual QVariant visit(const Vector* var);
+ virtual QVariant visit(const List* l);
+ virtual QVariant visit(const Matrix* m);
+ virtual QVariant visit(const MatrixRow* c);
+ virtual QVariant visit(const Apply* a);
+ virtual QVariant visit(const CustomObject* c);
- QString result() const { return m_result; }
+ QVariant result() const { return m_result; }
private:
- QString m_result;
+ QVariant m_result;
static operatorToString m_operatorToPresentation[Operator::nOfOps];
};
diff --git a/analitza/matrix.cpp b/analitza/matrix.cpp
index 6714ac8..d432641 100644
--- a/analitza/matrix.cpp
+++ b/analitza/matrix.cpp
@@ -17,7 +17,7 @@
*************************************************************************************/
#include "matrix.h"
-#include "expressionwriter.h"
+#include "abstractexpressionvisitor.h"
#include "vector.h"
using namespace Analitza;
@@ -57,9 +57,9 @@ bool Matrix::matches(const Object* exp, QMap< QString, const \
Object* >* found) c return matching;
}
-QString Matrix::visit(ExpressionWriter* exp) const
+QVariant Matrix::accept(AbstractExpressionVisitor* exp) const
{
- return exp->accept(this);
+ return exp->visit(this);
}
void Matrix::appendBranch(Object* o)
@@ -98,9 +98,9 @@ MatrixRow::MatrixRow(int size)
: Vector(Object::matrixrow, size)
{}
-QString MatrixRow::visit(ExpressionWriter* e) const
+QVariant MatrixRow::accept(AbstractExpressionVisitor* e) const
{
- return e->accept(this);
+ return e->visit(this);
}
MatrixRow* MatrixRow::copy() const
diff --git a/analitza/matrix.h b/analitza/matrix.h
index 69c109d..68e2189 100644
--- a/analitza/matrix.h
+++ b/analitza/matrix.h
@@ -30,7 +30,7 @@ class ANALITZA_EXPORT MatrixRow : public Vector
{
public:
MatrixRow(int size=0);
- virtual QString visit(ExpressionWriter* e) const;
+ virtual QVariant accept(AbstractExpressionVisitor* e) const;
MatrixRow* copy() const;
};
@@ -47,7 +47,7 @@ class ANALITZA_EXPORT Matrix : public Object
virtual Object* copy() const;
virtual bool matches(const Object* exp, QMap< QString, const Object* >* found) \
const;
- virtual QString visit(ExpressionWriter* exp) const;
+ virtual QVariant accept(AbstractExpressionVisitor* exp) const;
const_iterator constBegin() const { return m_rows.constBegin(); }
const_iterator constEnd() const { return m_rows.constEnd(); }
iterator begin() { return m_rows.begin(); }
diff --git a/analitza/object.cpp b/analitza/object.cpp
index b485d07..694eedb 100644
--- a/analitza/object.cpp
+++ b/analitza/object.cpp
@@ -22,5 +22,5 @@
QString Analitza::Object::toString() const
{
StringExpressionWriter e(this);
- return e.result();
+ return e.result().toString();
}
diff --git a/analitza/object.h b/analitza/object.h
index aafd114..9c202ea 100644
--- a/analitza/object.h
+++ b/analitza/object.h
@@ -26,7 +26,7 @@
namespace Analitza
{
-class ExpressionWriter;
+class AbstractExpressionVisitor;
/**
* \internal
@@ -69,7 +69,7 @@ public:
QString toString() const;
/** Returns some string depending on the visior */
- virtual QString visit(ExpressionWriter* exp) const =0;
+ virtual QVariant accept(AbstractExpressionVisitor* exp) const = 0;
virtual bool isZero() const { return false; }
diff --git a/analitza/operator.cpp b/analitza/operator.cpp
index a2d8501..0acbcae 100644
--- a/analitza/operator.cpp
+++ b/analitza/operator.cpp
@@ -17,7 +17,7 @@
*************************************************************************************/
#include "operator.h"
-#include "expressionwriter.h"
+#include "abstractexpressionvisitor.h"
using namespace Analitza;
@@ -52,9 +52,9 @@ const char Operator::words[nOfOps][14] = {
"function"
};
-QString Operator::visit(ExpressionWriter* e) const
+QVariant Operator::accept(AbstractExpressionVisitor* e) const
{
- return e->accept(this);
+ return e->visit(this);
}
QString Operator::name() const
diff --git a/analitza/operator.h b/analitza/operator.h
index 0e61b21..51c578c 100644
--- a/analitza/operator.h
+++ b/analitza/operator.h
@@ -122,7 +122,7 @@ class ANALITZA_EXPORT Operator : public Object
virtual bool matches(const Object*, QMap<QString, const Object*>*) const;
virtual bool decorate(const QMap< QString, Object** >& ) { return false; }
- virtual QString visit(ExpressionWriter*) const;
+ virtual QVariant accept(AbstractExpressionVisitor*) const;
virtual Operator* copy() const;
static const char words[nOfOps][14];
diff --git a/analitza/stringexpressionwriter.cpp \
b/analitza/stringexpressionwriter.cpp index 90594e8..cb5c95f 100644
--- a/analitza/stringexpressionwriter.cpp
+++ b/analitza/stringexpressionwriter.cpp
@@ -31,11 +31,11 @@
using namespace Analitza;
template <class T>
-QStringList StringExpressionWriter::allValues(T it, const T& itEnd, \
ExpressionWriter* writer) +QStringList StringExpressionWriter::allValues(T it, const \
T& itEnd, AbstractExpressionVisitor* writer) {
QStringList elements;
for(; it!=itEnd; ++it)
- elements += (*it)->visit(writer);
+ elements += (*it)->accept(writer).toString();
return elements;
}
@@ -63,43 +63,43 @@ const QMap<Operator::OperatorType, QString> \
StringExpressionWriter::s_operators= \
StringExpressionWriter::StringExpressionWriter(const Object* o) {
if (o)
- m_result=o->visit(this);
+ m_result=o->accept(this);
}
-QString StringExpressionWriter::accept(const Ci* var)
+QVariant StringExpressionWriter::visit(const Ci* var)
{
return var->name();
}
-QString StringExpressionWriter::accept(const Operator* op)
+QVariant StringExpressionWriter::visit(const Operator* op)
{
return op->name();
}
-QString StringExpressionWriter::accept(const Vector* vec)
+QVariant StringExpressionWriter::visit(const Vector* vec)
{
return QString("vector { %1 \
}").arg(allValues<Vector::const_iterator>(vec->constBegin(), vec->constEnd(), \
this).join(QString(", "))); }
-QString StringExpressionWriter::accept(const Matrix* m)
+QVariant StringExpressionWriter::visit(const Matrix* m)
{
return QString("matrix { %1 }").arg(allValues(m->constBegin(), m->constEnd(), \
this).join(QString(", "))); }
-QString StringExpressionWriter::accept(const MatrixRow* mr)
+QVariant StringExpressionWriter::visit(const MatrixRow* mr)
{
return QString("matrixrow { %1 }").arg(allValues(mr->constBegin(), mr->constEnd(), \
this).join(QString(", "))); }
-QString StringExpressionWriter::accept(const List* vec)
+QVariant StringExpressionWriter::visit(const List* vec)
{
if(!vec->isEmpty() && vec->at(0)->type()==Object::value && \
static_cast<Cn*>(vec->at(0))->format()==Cn::Char)
- return "\""+AnalitzaUtils::listToString(vec)+"\"";
+ return QString("\""+AnalitzaUtils::listToString(vec)+"\"");
else
return QString("list { %1 \
}").arg(allValues<List::const_iterator>(vec->constBegin(), vec->constEnd(), \
this).join(QString(", "))); }
-QString StringExpressionWriter::accept(const Cn* var)
+QVariant StringExpressionWriter::visit(const Cn* var)
{
if(var->isBoolean())
return var->isTrue() ? "true" : "false";
@@ -138,7 +138,7 @@ int StringExpressionWriter::weight(const Operator* op, int size, \
int pos) }
}
-QString StringExpressionWriter::accept ( const Analitza::Apply* a )
+QVariant StringExpressionWriter::visit(const Analitza::Apply* a)
{
Operator op=a->firstOperator();
QStringList ret;
@@ -149,13 +149,13 @@ QString StringExpressionWriter::accept ( const Analitza::Apply* \
a ) if(a->ulimit() || a->dlimit()) {
bounds += '=';
if(a->dlimit())
- bounds += a->dlimit()->visit(this);
+ bounds += a->dlimit()->accept(this).toString();
bounds += "..";
if(a->ulimit())
- bounds += a->ulimit()->visit(this);
+ bounds += a->ulimit()->accept(this).toString();
}
else if(a->domain())
- bounds += '@'+a->domain()->visit(this);
+ bounds += '@'+a->domain()->accept(this).toString();
int i = 0;
foreach(Object* o, a->m_params) {
@@ -165,11 +165,11 @@ QString StringExpressionWriter::accept ( const Analitza::Apply* \
a ) Q_ASSERT(false);
break;
case Object::variable:
- ret << static_cast<const Ci*>(o)->visit(this);
+ ret << static_cast<const Ci*>(o)->accept(this).toString();
break;
case Object::apply: {
const Apply *c = (const Apply*) o;
- QString s = c->visit(this);
+ QString s = c->accept(this).toString();
if(s_operators.contains(op.operatorType()) && !c->isUnary()) {
Operator child_op = c->firstOperator();
@@ -179,7 +179,7 @@ QString StringExpressionWriter::accept ( const Analitza::Apply* a \
) ret << s;
} break;
default:
- ret << o->visit(this);
+ ret << o->accept(this).toString();
break;
}
++i;
@@ -214,13 +214,13 @@ QString StringExpressionWriter::accept ( const Analitza::Apply* \
a ) bounding = ':'+bounding +bounds;
}
- toret += QString("%1(%2%3)").arg(op.visit(this)).arg(ret.join(", \
")).arg(bounding); + toret += \
QString("%1(%2%3)").arg(op.accept(this).toString()).arg(ret.join(", \
")).arg(bounding); }
return toret;
}
-QString StringExpressionWriter::accept(const Container* var)
+QVariant StringExpressionWriter::visit(const Container* var)
{
QStringList ret = allValues(var->constBegin(), var->constEnd(), this);
@@ -261,7 +261,7 @@ QString StringExpressionWriter::accept(const Container* var)
return toret;
}
-QString StringExpressionWriter::accept(const CustomObject*)
+QVariant StringExpressionWriter::visit(const CustomObject*)
{
return "CustomObject";
}
diff --git a/analitza/stringexpressionwriter.h b/analitza/stringexpressionwriter.h
index e8c0ccd..523de30 100644
--- a/analitza/stringexpressionwriter.h
+++ b/analitza/stringexpressionwriter.h
@@ -19,7 +19,7 @@
#ifndef STRINGEXPRESSIONWRITER_H
#define STRINGEXPRESSIONWRITER_H
-#include "expressionwriter.h"
+#include "abstractexpressionvisitor.h"
#include "operator.h"
namespace Analitza
@@ -33,31 +33,31 @@ namespace Analitza
* \brief This class represents the string expression writer.
*/
-class StringExpressionWriter : public ExpressionWriter
+class StringExpressionWriter : public AbstractExpressionVisitor
{
public:
StringExpressionWriter(const Object* o);
- virtual QString accept(const Ci* var);
- virtual QString accept(const Cn* var);
- virtual QString accept(const Container* var);
- virtual QString accept(const Operator* var);
- virtual QString accept(const Vector* var);
- virtual QString accept(const List* l);
- virtual QString accept(const Matrix* m);
- virtual QString accept(const MatrixRow* mr);
- virtual QString accept(const Apply* a);
- virtual QString accept(const CustomObject* c);
+ virtual QVariant visit(const Ci* var);
+ virtual QVariant visit(const Cn* var);
+ virtual QVariant visit(const Container* var);
+ virtual QVariant visit(const Operator* var);
+ virtual QVariant visit(const Vector* var);
+ virtual QVariant visit(const List* l);
+ virtual QVariant visit(const Matrix* m);
+ virtual QVariant visit(const MatrixRow* mr);
+ virtual QVariant visit(const Apply* a);
+ virtual QVariant visit(const CustomObject* c);
- QString result() const { return m_result; }
+ QVariant result() const { return m_result; }
static int weight(const Analitza::Operator* op, int size, int pos);
static const QMap<Operator::OperatorType, QString> s_operators;
private:
template <class T>
- static QStringList allValues(T it, const T& itEnd, ExpressionWriter* writer);
+ static QStringList allValues(T it, const T& itEnd, AbstractExpressionVisitor* \
writer);
- QString m_result;
+ QVariant m_result;
};
}
diff --git a/analitza/value.cpp b/analitza/value.cpp
index 7d4e49a..c1cd81c 100644
--- a/analitza/value.cpp
+++ b/analitza/value.cpp
@@ -18,7 +18,7 @@
#include "value.h"
#include "operator.h"
-#include "expressionwriter.h"
+#include "abstractexpressionvisitor.h"
#include <QDomElement>
@@ -35,9 +35,9 @@ Object* Cn::copy() const
}
-QString Cn::visit(ExpressionWriter* e) const
+QVariant Cn::accept(AbstractExpressionVisitor* e) const
{
- return e->accept(this);
+ return e->visit(this);
}
bool Cn::setValue(const QDomElement& val)
diff --git a/analitza/value.h b/analitza/value.h
index 89bc2ef..fc4b786 100644
--- a/analitza/value.h
+++ b/analitza/value.h
@@ -148,7 +148,7 @@ class ANALITZA_EXPORT Cn : public Object
QChar character() const { Q_ASSERT(m_format==Char); return QChar(m_char); }
- virtual QString visit(ExpressionWriter*) const;
+ virtual QVariant accept(AbstractExpressionVisitor*) const;
virtual bool isZero() const { return m_value==0.; }
virtual bool matches(const Object* exp, QMap< QString, const Object* >* found) \
const;
diff --git a/analitza/variable.cpp b/analitza/variable.cpp
index b98365e..6c57c41 100644
--- a/analitza/variable.cpp
+++ b/analitza/variable.cpp
@@ -17,7 +17,7 @@
*************************************************************************************/
#include "variable.h"
-#include "expressionwriter.h"
+#include "abstractexpressionvisitor.h"
#include "analitzautils.h"
using namespace Analitza;
@@ -39,9 +39,9 @@ Ci* Ci::copy() const
return c;
}
-QString Ci::visit(ExpressionWriter* e) const
+QVariant Ci::accept(AbstractExpressionVisitor* e) const
{
- return e->accept(this);
+ return e->visit(this);
}
QString Ci::toMathML() const
diff --git a/analitza/variable.h b/analitza/variable.h
index 2f8514c..f861573 100644
--- a/analitza/variable.h
+++ b/analitza/variable.h
@@ -57,7 +57,7 @@ class ANALITZA_EXPORT Ci : public Object
/** Returns the HTML representation of the variable */
QString toHtml() const;
- virtual QString visit(ExpressionWriter*) const;
+ virtual QVariant accept(AbstractExpressionVisitor*) const;
virtual bool matches(const Object* pattern, QMap<QString, const Object*>* found) \
const; Ci* copy() const;
diff --git a/analitza/vector.cpp b/analitza/vector.cpp
index d7b5836..bd92d0e 100644
--- a/analitza/vector.cpp
+++ b/analitza/vector.cpp
@@ -18,7 +18,7 @@
#include "vector.h"
#include "expression.h"
-#include "expressionwriter.h"
+#include "abstractexpressionvisitor.h"
#include "analitzautils.h"
using namespace Analitza;
@@ -66,9 +66,9 @@ void Vector::appendBranch(Object* o)
m_elements.append(o);
}
-QString Vector::visit(ExpressionWriter* e) const
+QVariant Vector::accept(AbstractExpressionVisitor* e) const
{
- return e->accept(this);
+ return e->visit(this);
}
bool Vector::isZero() const
diff --git a/analitza/vector.h b/analitza/vector.h
index 338bf81..cc6d50c 100644
--- a/analitza/vector.h
+++ b/analitza/vector.h
@@ -55,7 +55,7 @@ class ANALITZA_EXPORT Vector : public Object
void setAt(int i, Object* o) { m_elements[i]=o; }
QList<Object*> values() const { return m_elements.toList(); }
- virtual QString visit (ExpressionWriter* e) const;
+ virtual QVariant accept(AbstractExpressionVisitor* e) const;
virtual bool isZero() const;
virtual bool matches(const Object* pattern, QMap< QString, const Object* >* found) \
const;
[prev in list] [next in list] [prev in thread] [next in thread]
Configure |
About |
News |
Add a list |
Sponsored by KoreLogic