rtreeactionrule.cpp

Go to the documentation of this file.

#include "rtreeactionrule.h"

ActionWrite::ActionWrite(Node* iexpr) : expr(iexpr) {};
ActionWrite::~ActionWrite() {
  delete expr;
};

void ActionWrite::execute(NameSpace &nameSpace){
  cout << expr->evaluate(nameSpace) << endl;
};

Action* ActionWrite::copy() const{
  return new ActionWrite(expr->copy());
};

Action* ActionWrite::substitute(const Node::Assignment &assign){
  substituteNode(expr,assign);
  return this;
};


ActionSet::ActionSet(Node* iname, Constant* iattribute, Node* iexpr, bool iglobal) 
  : name(iname), attribute(iattribute->getValue()),expr(iexpr), global(iglobal) 
{
  delete iattribute;
};
ActionSet::~ActionSet(){
  delete name;
  delete expr;
};

void ActionSet::execute(NameSpace &nameSpace){
  nameSpace.setAttributeValue(name->toString(),
                              attribute,
                              expr->evaluate(nameSpace),global);
};

Action* ActionSet::copy() const{
  return new ActionSet(name->copy(), new Constant(attribute), expr->copy(), global);
};

Action* ActionSet::substitute(const Node::Assignment &assign){
  substituteNode(name,assign);
  substituteNode(expr,assign);
  return this;
};

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

ActionList* ActionList::copy() const{
  ActionList* result = new ActionList();
  const_iterator it = begin();
  const_iterator eit = end();
  while (it!=eit){
    result->push_back((*it)->copy());
    it++;
  };
  return result;
}

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

void ActionList::execute(NameSpace &nameSpace) const{
  const_iterator it = begin();
  const_iterator eit = end();
  while (it!=eit){
    (*it)->execute(nameSpace);
    it++;
  };
};

ActionList* ActionList::push_back(Action* action){
    list<Action*>::push_back(action);
    return this;
};



ActionRule::ActionRule(List* iphpInPattern, ActionList* iactions)
  : phpInPattern(iphpInPattern), actions(iactions) {};

ActionRule::~ActionRule(){
  delete phpInPattern;
  delete actions;
};

bool ActionRule::execute(RuleContext* context, List* phpIn, List* phpOut, List* tplOut,Node::Assignment &assign) const {
  if (phpInPattern->matchToBegining(phpIn,assign,context->getNameSpace())){
    ActionList *toDo = actions->copy()->substitute(assign);
    toDo->execute(context->getNameSpace());
    for (int i=0 ; i<phpInPattern->getLength() ; i++){
      phpOut->push_back(phpIn->front());
      phpIn->pop_front();
    };
    delete toDo;
    return true;
  }
  return false;
};

Rule* ActionRule::copy(){
  return new ActionRule(phpInPattern->copyList(),actions->copy());
};

Rule* ActionRule::substitute(const Node::Assignment &assign){
  phpInPattern->substitute(assign);
  actions->substitute(assign);
  return this;
};

ostream& ActionRule::print(ostream& os) const{
  os << "ActionRule - ";
  phpInPattern->print(os);
  //      tplOutPattern->print(os);
  return os;
};


RuleWithActionRule::RuleWithActionRule(Rule* irule, ActionList* iactions)
  : rule(irule), actions(iactions) {};

RuleWithActionRule::~RuleWithActionRule(){
  delete rule;
  delete actions;
};

bool RuleWithActionRule::execute(RuleContext* context, List* phpIn, List* phpOut, List* tplOut,Node::Assignment &assign) const {
  if (rule->execute(context,phpIn,phpOut,tplOut,assign)) {
    ActionList *toDo = actions->copy()->substitute(assign);
    toDo->execute(context->getNameSpace());
    delete toDo;
    return true;
  }
  return false;
};

Rule* RuleWithActionRule::copy(){
  return new RuleWithActionRule(rule->copy(),actions->copy());
};

Rule* RuleWithActionRule::substitute(const Node::Assignment &assign){
  rule->substitute(assign);
  actions->substitute(assign);
  return this;
};

ostream& RuleWithActionRule::print(ostream& os) const{
  os << "RuleWithActionRule - " << rule;
  return os;
};

---