ctree.h

Go to the documentation of this file.

#ifndef _CTREE_H_
#define _CTREE_H_

#include "stree.h"


class ContextMatch : public Node
{
 protected:
  Node* node;
  Tester* tester;
 public:
  ContextMatch(Node* inode, Tester* itester) : node(inode), tester(itester) {};

  virtual ~ContextMatch(){
    delete node;
    delete tester;
  };

  virtual SType getType() const { return node->getType(); };
  
  virtual string getName() const { return node->getName(); };
    
  virtual ostream& print(ostream &os) const{
    os << "ContextMatch{";
    node->print(os);
    os << "}";
    return os;
  };
  
  virtual ostream& php(ostream &os) const{
    return node->php(os);
  }

  virtual bool match(const Node* p, Assignment &assign, const NameSpace &nameSpace)const {
    Tester* toTest = tester->copy()->substitute(assign);
    if (!toTest->test(p, nameSpace)) {
      delete toTest;
      return false;
    }
    delete toTest;
    return node->match(p,assign,nameSpace);
  };

  virtual bool matchToBegining(const List* p, Assignment &assign, const NameSpace &nameSpace)const {
    if (!tester->test(p, nameSpace)) return false;
    return node->matchToBegining(p,assign,nameSpace);
  };

  virtual bool compare(const Node* p) const {
    return node->compare(p);
  };
    
  virtual Node* copy() const {
    return new ContextMatch(node->copy(), tester->copy());
  };
  
  virtual void getVariables(VariableList &vlist) const{
    node->getVariables(vlist);
  };  

  virtual string evaluate(const NameSpace &nameSpace) const{
    return node->evaluate(nameSpace);
  };

  virtual int getLength() const{
    return node->getLength();
  };

 protected:

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

};


class AttributeValue : public Node
{
 protected:
  Node* variable;
  Node* attribute;
  const bool global;
 public:
  AttributeValue(Node* ivariable, Node* iattribute, bool iglobal) : variable(ivariable), attribute(iattribute), global(iglobal) {};

  virtual ~AttributeValue(){
    delete variable;
    delete attribute;
  };

  virtual SType getType() const { throw "ERROR: AttributeValue::getType"; };
  
  virtual string getName() const { throw "ERROR: AttributeValue::getName"; };
    
  virtual ostream& print(ostream &os) const{
    os << "AttributeValue{";
    variable->print(os);
    attribute->print(os);
    os << "}";
    return os;
  };
  
  virtual ostream& php(ostream &os) const{
    throw "ERROR: AttributeValue::php";
  }

  virtual bool match(const Node* p, Assignment &assign, const NameSpace &nameSpace)const {
    throw "ERROR: AttributeValue::match";
  };

  virtual bool matchToBegining(const List* p, Assignment &assign, const NameSpace &nameSpace)const {
    throw "ERROR: AttributeValue::matchToBegining";
  };

  virtual bool compare(const Node* p) const {
    throw "ERROR: AttributeValue::compare";
  };
    
  virtual Node* copy() const {
    return new AttributeValue(variable->copy(), attribute->copy(),global);
  };
  
  virtual void getVariables(VariableList &vlist) const{
    throw "ERROR: AttributeValue::getVariables";
  };  

  virtual string evaluate(const NameSpace &nameSpace) const{    
    return nameSpace.getAttributeValue(variable->toString(), attribute->toString(),global);
  };

 protected:

  virtual Node* substitute(const Assignment &assign){
    substituteNode(variable,assign);
    substituteNode(attribute,assign);
    return this;
  };

};


#endif

---