def visit_RelClear(self, node):
code = (node, )
auxmaps = self.auxmaps_by_rel.get(node.rel, set())
for auxmap in auxmaps:
clear_code = (L.MapClear(auxmap.map), )
code = L.insert_rel_maint(code, clear_code, L.SetRemove())
wraps = self.wraps_by_rel.get(node.rel, set())
for wrap in wraps:
clear_code = (L.RelClear(wrap.rel), )
code = L.insert_rel_maint(code, clear_code, L.SetRemove())
return code
def visit_RelClear(self, node):
if node.rel not in self.rels:
return node
code = (node, )
clear_code = (L.RelClear(self.result_var), )
code = L.insert_rel_maint(code, clear_code, L.SetRemove())
return code
def visit_MapClear(self, node):
sfm = self.setfrommaps_by_map.get(node.map, None)
if sfm is None:
return node
code = (node, )
clear_code = (L.RelClear(sfm.rel), )
code = L.insert_rel_maint(code, clear_code, L.SetRemove())
return code
def visit_AttrDelete(self, node):
if node.attr not in self.objrels.Fs:
return
lookup = L.Attribute(node.obj, node.attr)
pair = L.Tuple([node.obj, lookup])
var = next(self.fresh_vars)
return (L.Assign(var, pair),
L.RelUpdate(N.F(node.attr), L.SetRemove(), var))
def visit_DictDelete(self, node):
if not self.objrels.MAP:
return
lookup = L.DictLookup(node.target, node.key, None)
triple = L.Tuple([node.target, node.key, lookup])
var = next(self.fresh_vars)
return (L.Assign(var, triple),
L.RelUpdate(N.MAP, L.SetRemove(), var))
def visit_MapDelete(self, node):
sfm = self.setfrommaps_by_map.get(node.map, None)
if sfm is None:
return node
code = (node, )
func_name = sfm.get_maint_func_name('delete')
call_code = (L.Expr(L.Call(func_name, [L.Name(node.key)])), )
code = L.insert_rel_maint(code, call_code, L.SetRemove())
return code
def visit_Module(self, node):
node = self.generic_visit(node)
funcs = []
for auxmaps in self.auxmaps_by_rel.values():
for auxmap in auxmaps:
for op in [L.SetAdd(), L.SetRemove()]:
func = make_auxmap_maint_func(self.fresh_vars, auxmap, op)
funcs.append(func)
for sfm in self.setfrommaps_by_map.values():
for op in ['assign', 'delete']:
func = make_setfrommap_maint_func(self.fresh_vars, sfm, op)
funcs.append(func)
for wraps in self.wraps_by_rel.values():
for wrap in wraps:
for op in [L.SetAdd(), L.SetRemove()]:
func = make_wrap_maint_func(self.fresh_vars, wrap, op)
funcs.append(func)
func_names = L.get_defined_functions(tuple(funcs))
self.maint_funcs.update(func_names)
node = node._replace(body=tuple(funcs) + node.body)
return node
def visit_RelClear(self, node):
# We should clear if we are not using demand and our operand is
# being cleared, or if we are using demand and our demand set is
# being cleared.
aggrinv = self.aggrinv
uses_demand = aggrinv.uses_demand
if uses_demand:
should_clear = node.rel == aggrinv.restr
else:
should_clear = node.rel == aggrinv.rel
if not should_clear:
return node
clear_code = (L.MapClear(self.aggrinv.map), )
code = L.insert_rel_maint((node, ), clear_code, L.SetRemove())
return code
def visit_Module(self, node):
node = self.generic_visit(node)
fv = self.fresh_vars
ops = [L.SetAdd(), L.SetRemove()]
funcs = []
for op in ops:
func = make_aggr_oper_maint_func(fv, self.aggrinv, op)
funcs.append(func)
if self.aggrinv.uses_demand:
for op in ops:
func = make_aggr_restr_maint_func(fv, self.aggrinv, op)
funcs.append(func)
func_names = L.get_defined_functions(tuple(funcs))
self.maint_funcs.update(func_names)
node = node._replace(body=tuple(funcs) + node.body)
return node
def visit_Module(self, node):
ct = self.clausetools
node = self.generic_visit(node)
funcs = []
for rel in self.rels:
for op in [L.SetAdd(), L.SetRemove()]:
fresh_var_prefix = next(self.fresh_vars)
func = make_comp_maint_func(ct,
fresh_var_prefix,
self.fresh_join_names,
self.comp,
self.result_var,
rel,
op,
counted=self.counted)
funcs.append(func)
func_names = L.get_defined_functions(tuple(funcs))
self.maint_funcs.update(func_names)
node = node._replace(body=tuple(funcs) + node.body)
return node
