testers.h

Go to the documentation of this file.

#ifndef _TESTERS_H_
#define _TESTERS_H_

#include "streenode.h"
#include "namespace.h"
//#include "config.h"
#include <list>

class NameTester : public Node::Tester{
  Node *name;
public:
  NameTester(Node *iname) : name(iname) {};
  ~NameTester(){
    delete name;
  };

  virtual bool test(const Node* node, const NameSpace& nameSpace) const {
    cout << "NODE NAME " << node->toString() << " " << (name->toString()) << " " << (node->toString() == name->toString()) << endl;
    return (node->toString() == name->toString());
  };
  virtual Tester* copy() const {
    return new NameTester(name->copy());
  };
  virtual Tester* substitute(const Node::Assignment &assign){
    substituteNode(name,assign);
    return this;
  };
};

class TypeTester : public Node::Tester{
  Node *type;
public:
  TypeTester(Node *itype) : type(itype) {};
  ~TypeTester(){
    delete type;
  };

  virtual bool test(const Node* node, const NameSpace& nameSpace) const {
    cout << "NODE NAME " << node->getName() << " " << (type->toString()) << " " << (node->getName() == type->toString()) << endl;
    return (node->getName() == type->toString());
  };
  virtual Tester* copy() const {
    return new TypeTester(type->copy());
  };
  virtual Tester* substitute(const Node::Assignment &assign){
    substituteNode(type,assign);
    return this;
  };
};

class AdaptedTester : public Node::Tester{
protected:
  Tester *tester;
public:
  AdaptedTester(Tester *itester) : tester(itester) {};
  
  virtual ~AdaptedTester(){
    delete tester;
  };
  virtual Tester* substitute(const Node::Assignment &assign){
    tester->substitute(assign);
    return this;
  };
};

class ExistsTester : public AdaptedTester{
public:
  ExistsTester(Tester *itester) : AdaptedTester(itester) {};
  
  virtual bool test(const Node* node, const NameSpace& nameSpace) const {
    return node->exists(tester, nameSpace);
  };

  virtual Tester* copy() const {
    return new ExistsTester(tester->copy());
  };
};

class ForallTester : public AdaptedTester{
public:
  ForallTester(Tester *itester) : AdaptedTester(itester) {};
  
  virtual bool test(const Node* node, const NameSpace& nameSpace) const {
    return node->forall(tester, nameSpace);
  };

  virtual Tester* copy() const {
    return new ForallTester(tester->copy());
  };
};

class NotTester : public AdaptedTester{
public:
  NotTester(Tester *itester) : AdaptedTester(itester) {};
  
  virtual bool test(const Node* node, const NameSpace& nameSpace) const {
    return !tester->test(node, nameSpace);
  };

  virtual Tester* copy() const {
    return new NotTester(tester->copy());
  };
};

class AttributeIssetTester : public Node::Tester{
  const string attribute;
  const bool global;
public:
  AttributeIssetTester(const string& iattribute, const bool iglobal) : attribute(iattribute), global(iglobal) {};
  AttributeIssetTester(const Constant* iattribute, const bool iglobal) : attribute(iattribute->getValue()), global(iglobal) { delete iattribute; };

  virtual bool test(const Node* node, const NameSpace& nameSpace) const {
    return nameSpace.isAttributeSet(node->toString(),attribute,global);
  };

  virtual Tester* copy() const {
    return new AttributeIssetTester(attribute,global);
  };  

  virtual Tester* substitute(const Node::Assignment &assign){
    return this;
  };

};

class AttributeIsequalTester : public Node::Tester{
  const string attribute;
  Node* value;
  const bool global;
public:
  AttributeIsequalTester(const string& iattribute, Node* ivalue, const bool iglobal) 
    : attribute(iattribute), value(ivalue), global(iglobal) {};
  AttributeIsequalTester(const Constant* iattribute, Node* ivalue, const bool iglobal) 
    : attribute(iattribute->getValue()), value(ivalue), global(iglobal) { delete iattribute; };

  ~AttributeIsequalTester(){
    delete value;
  };

  virtual bool test(const Node* node, const NameSpace& nameSpace) const {
    return nameSpace.isAttributeEqual(node->toString(),attribute,value->toString(),global);
  };

  virtual Tester* copy() const {
    return new AttributeIsequalTester(new Constant(attribute),value->copy(),global);
  };  

  virtual Tester* substitute(const Node::Assignment &assign){
    substituteNode(value,assign);
    return this;
  };
};

class LocalAttributeIssetTester : public Node::Tester{
  const string attribute;
  const bool global;
public:
  LocalAttributeIssetTester(const string& iattribute, const bool iglobal) : attribute(iattribute), global(iglobal) {};
  LocalAttributeIssetTester(const Constant* iattribute, const bool iglobal) : attribute(iattribute->getValue()), global(iglobal) { delete iattribute; };

  virtual bool test(const Node* node, const NameSpace& nameSpace) const {
    return nameSpace.isAttributeSet("",attribute,global);
  };

  virtual Tester* copy() const {
    return new LocalAttributeIssetTester(attribute,global);
  };  

  virtual Tester* substitute(const Node::Assignment &assign){
    return this;
  };

};

class LocalAttributeIsequalTester : public Node::Tester{
  const string attribute;
  Node* value;
  const bool global;
public:
  LocalAttributeIsequalTester(const string& iattribute, Node* ivalue, const bool iglobal) 
    : attribute(iattribute), value(ivalue), global(iglobal) {};
  LocalAttributeIsequalTester(const Constant* iattribute, Node* ivalue, const bool iglobal) 
    : attribute(iattribute->getValue()), value(ivalue), global(iglobal) { delete iattribute; };

  ~LocalAttributeIsequalTester(){
    delete value;
  };

  virtual bool test(const Node* node, const NameSpace& nameSpace) const {
    return nameSpace.isAttributeEqual("",attribute,value->toString(),global);
  };

  virtual Tester* copy() const {
    return new LocalAttributeIsequalTester(new Constant(attribute),value->copy(),global);
  };  

  virtual Tester* substitute(const Node::Assignment &assign){
    substituteNode(value,assign);
    return this;
  };
};

class TesterSet : public Node::Tester, protected list<Node::Tester*> {
protected:
  TesterSet* copyContent(TesterSet* newTesterSet) const{
    const_iterator it = begin();
    const_iterator eit = end();
    while (it!=eit){
      newTesterSet->insert((*it)->copy());
      it++;
    };
    return newTesterSet;
  };

  TesterSet() {};
  TesterSet(Tester* tester) { push_back(tester); };

public:

  TesterSet* insert(Tester* tester){
    push_back(tester);
    return this;
  };

  virtual ~TesterSet(){
    iterator it = begin();
    iterator eit = end();
    while (it!=eit){
      delete *it;
      it++;
    };
  };

  virtual Tester* substitute(const Node::Assignment &assign){
    iterator it = begin();
    iterator eit = end();
    while (it!=eit){
      (*it)->substitute(assign);
      it++;
    };
    return this;
  };
};

class TesterSetForall : public TesterSet{
public:
  TesterSetForall() : TesterSet() {};
  TesterSetForall(Tester* tester) : TesterSet(tester) {};
  TesterSetForall(Tester* tester1, Tester* tester2) { insert(tester1); insert(tester2); };

  virtual bool test(const Node* node, const NameSpace& nameSpace) const {
    const_iterator it = begin();
    const_iterator eit = end();
    while (it!=eit){
      if (!(*it)->test(node,nameSpace)) return false;
      it++;
    };
    return true;
  };

  virtual Tester* copy() const{
    return copyContent(new TesterSetForall());
  };
};

class TesterSetExists : public TesterSet{
public:
  TesterSetExists() : TesterSet() {};
  TesterSetExists(Tester* tester) : TesterSet(tester) { };
  TesterSetExists(Tester* tester1, Tester* tester2) { insert(tester1); insert(tester2); };

  virtual bool test(const Node* node, const NameSpace& nameSpace) const {
    const_iterator it = begin();
    const_iterator eit = end();
    while (it!=eit){
      if ((*it)->test(node,nameSpace)) return true;
      it++;
    };
    return false;
  };

  virtual Tester* copy() const{
    return copyContent(new TesterSetExists());
  };
};

#endif

---