value.cpp

Go to the documentation of this file.

#include <qpainter.h>
#include <qimage.h>
#include <typeinfo>
#include "value.h"
#include "vars.h"
#include "refs.h"
#include "text.h"
#include "image.h"
#include "ranges.h"
#include "line.h"
#include "box.h"

bool Value::equals(Value *other)
{
  if (typeid(*other)==typeid(*this))
    return equals_same_type(other);
  return false;
}

QString Expression::toString()
{
  QString result("(");
  result+=operat;
  for(vector<Value*>::iterator it=values.begin(); it!=values.end() ; it++)
    {
      result+=" ";
      result+=(*it)->toString();
    }
  return result+")";
}

bool Expression::equals_same_type(Value * other) 
{
  Expression * o = (Expression*)other;
  if (o->operat!=operat) return false;
  if (values.size() != o->values.size()) return false;
  for(unsigned int i = 0 ; i < values.size() ; i++)
    if (!values[i]->equals(o->values[i])) 
      return false;
  return true;
}

Data Expression::getSaveDescription(QString prefix)
{
  Token E;
  E["type"]=Symbol("expression");
  E["operator"]=String(operat);
  Array<1,Data> V(values.size());
  E["values"]=V;
  for(unsigned int i = 0 ; i < values.size() ; i++)
    V[i]=values[i]->getSaveDescription(prefix);
  return E;
}

Expression::Expression(Token data)
{
  operat = (String)data["operator"];
  Array<1,Data> arguments = data["values"];
  for(Array<1,Data>::ordered argument(arguments) ; argument.more() ; ++argument)
    values.push_back(Value::load(argument));
}

Value * ValueCopier::copyExpr(Expression * expr)
{
  Expression * result = new Expression(expr->op());
  for(int i = 0 ; i < expr->argc(); i ++)
    result->add(copy(expr->argv(i)));
  return result;
}

Value * ValueCopier::copyRange(Range * r)
{
  return new Range(copyRef(r->from),copyRef(r->to));
}

Value * ValueCopier::copyText(TextValue*vv)
{
  return new TextValue(vv->getText());
}

Value * ValueCopier::copy(Value * what)
{
  if (!what) return NULL;
  if (typeid(*what)==typeid(TextValue))
    return copyText((TextValue*)what);
  //  if (typeid(*what)==typeid(ImageValue))
  //    return what;
  //  if (typeid(*what)==typeid(Variable))
  //    return copyVar((Variable*)what);
  if (typeid(*what)==typeid(Reference))
    return copyRef((Reference*)what);
  if (typeid(*what)==typeid(Expression))
    return copyExpr((Expression*)what);
  if (typeid(*what)==typeid(Range))
    return copyRange((Range*)what);
  assert(0);
  return NULL;
}

Value * Value::load(Data from)
{
  if (from.type()==Symbol::type())
    return new Variable((Symbol)from);
  if (from.type()==String::type())
    return new TextValue((String)from);
  if (from.type()==Token::type())
    {
      Token compound = from;
      Symbol type = compound["type"];
      if (type==Symbol("expression"))
        return new Expression(compound);
      if (type==Symbol("image"))
        return new ImageValue(compound);
      if (type==Symbol("box"))
        return new BoxValue(compound);
      if (type==Symbol("point"))
        return new PointValue(compound);
      if (type==Symbol("line"))
        return new LineValue(compound);
      if (type==Symbol("reference"))
        return new Reference(compound);
      if (type==Symbol("range"))
        return new Range(compound);
    }
  printf("Cannot load value with the following text\n");
  DataTexter::write(from,stdout);
  assert(0);
}

QString ValueArray::toString()
{
  return "<Array>";
  //  QString result;
  //  for(int y = 0 ; y < sy ; y++)
  //    {
  //      result+="(array ";
  //      for(int x = 0 ; x < sx ; x++)
  //        {
  //        result+=" ";
  //        result+=values[x+y*sx]->toString();
  //        }
  //      result+=")";
  //    }
  //  return result+")";
}

bool ValueArray::equals_same_type(Value * other) 
{
  ValueArray * o = (ValueArray*)other;
  if (sx!=o->sx) return false;
  if (sy!=o->sy) return false;
  for(int y = 0 ; y < sy ; y++)
    for(int x = 0 ; x < sx ; x++)
      if (!values[x+y*sx]->equals(o->values[x+y*sy])) 
        return false;
  return true;
}

Data ValueArray::getSaveDescription(QString prefix)
{
  Token E;
  E["type"]=Symbol("array");
  Array<2,Data> V(sx,sy);
  E["values"]=V;
  for(Array<2,Data>::positions xy(V) ; xy.more(); ++xy)
    xy=values[xy[0]+xy[1]*sx]->getSaveDescription(prefix);
  return E;
}

void ValueArray::set(int x, int y, Value *v)
{
  assert(values);
  values[x+y*sx]=v;
}

ValueArray::ValueArray(Token data)
{
  Array<2,Data> arguments = data["values"];
  sx = arguments.size(0);
  sy = arguments.size(1);
  values = new Value*[sx*sy];
  for(Array<2,Data>::values a(arguments) ; a.more() ; ++a)
    values[a[0]+a[1]*sx]=Value::load(a);
}

ValueArray::ValueArray(int x, int y)
{
  sx = x;
  sy = y;
  values = new Value*[sx*sy];
}

---