def enterUpdateStmt(self):
     self._actualFilter = UpdateManipulator(self.__alu)
 def enterDeleteStmt(self):
     self._actualFilter = DeleteManipulator(self.__alu)
class FilterVisitor(QueryVisitor):
    '''
    this will instantiate all filters on the streams
    meaning
    
      UPDATE DELETE
    '''
    def __init__(self, relations, alu):
        '''
        @param relations: a map of all known relations with name as key and the
                          relation itself as value.
        @type relations: map<str, RelationProxy>
        @param alu: the ALU to be used to operate.
        @type alu: ALU
        '''
        super(FilterVisitor, self).__init__()
        self._log = logging.getLogger(__name__+'.'+self.__class__.__name__)
        self.__expr  = ExpressionEvalBuilder(alu)
        self.__logic = LogicBuilder(alu)
        self.__rels = relations
        self.__alu  = alu

        self._actualFilter  = None # should the visit be considered.
        self._actualRelName = None
        self._actualSel     = None
        self._exprStack     = None

    def enterUpdateStmt(self):
        self._actualFilter = UpdateManipulator(self.__alu)

    def leaveUpdateStmt(self):

        name = self._actualRelName
        if not self.__rels.has_key(name):
            raise IllegalCondition('update on unknown relation "%s"' % name)
        self.__rels[name].addFilter(self._actualFilter)
        self._actualFilter  = None
        self._actualRelName = None
        self._actualSel     = None
        self._exprStack     = None

    def enterDeleteStmt(self):
        self._actualFilter = DeleteManipulator(self.__alu)

    def leaveDeleteStmt(self):
        name = self._actualRelName
        if not self.__rels.has_key(name):
            raise IllegalCondition('delete on unknown relation "%s"' % name)
        self.__rels[name].addFilter(self._actualFilter)
        self._actualFilter  = None
        self._actualRelName = None
        self._actualSel     = None
        self._exprStack     = None

    def setTargetRelation(self, name):
        if self._actualFilter is not None:
            self._actualRelName = name
        
    def enterSelection(self):
        if self._actualFilter is not None:
            pass

    def leaveSelection(self):
        if self._actualFilter is not None:
            self._actualFilter.setSelection(self.__logic.getResult())

    def enterAlteration(self):
        if self._actualFilter is not None:
            self._exprStack = list()
    
    def leaveAlteration(self):
        if self._exprStack is not None:
            path = self._exprStack[0]
            expr = self._exprStack[1]
            self._actualFilter.addAlteration(path, expr)
            self._exprStack = None
    
    def enterDrop(self):
        self._exprStack = list()

    def leaveDrop(self):
        self._actualFilter.addRemoval(self._exprStack[0])
        self._exprStack = None

    def acceptLogic(self, logic):
        if self._actualFilter is not None:
            logic.walk(self.__logic)

    def acceptExpression(self, expr):
        if self._actualFilter is None:
            return
        
        if self._exprStack is None:
            expr.walk(self.__expr)
        else:
            if len(self._exprStack)==0:
                self._exprStack.append(expr)
            else:
                expr.walk(self.__expr)
                self._exprStack.append(self.__expr.getResult())