1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
|
/*******************************************************************************
* Copyright (c) 2004-2010 Gabor Bergmann and Daniel Varro
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v. 2.0 which is available at
* http://www.eclipse.org/legal/epl-v20.html.
*
* SPDX-License-Identifier: EPL-2.0
*******************************************************************************/
package tools.refinery.viatra.runtime.matchers.psystem.basicdeferred;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import tools.refinery.viatra.runtime.matchers.planning.QueryProcessingException;
import tools.refinery.viatra.runtime.matchers.psystem.IQueryReference;
import tools.refinery.viatra.runtime.matchers.psystem.PBody;
import tools.refinery.viatra.runtime.matchers.psystem.PConstraint;
import tools.refinery.viatra.runtime.matchers.psystem.PVariable;
import tools.refinery.viatra.runtime.matchers.psystem.VariableDeferredPConstraint;
import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
/**
* @author Gabor Bergmann
*
*/
public abstract class PatternCallBasedDeferred extends VariableDeferredPConstraint implements IQueryReference {
protected Tuple actualParametersTuple;
protected abstract void doDoReplaceVariables(PVariable obsolete, PVariable replacement);
protected abstract Set<PVariable> getCandidateQuantifiedVariables();
protected PQuery query;
private Set<PVariable> deferringVariables;
public PatternCallBasedDeferred(PBody pBody, Tuple actualParametersTuple,
PQuery pattern, Set<PVariable> additionalAffectedVariables) {
super(pBody, union(actualParametersTuple.<PVariable> getDistinctElements(), additionalAffectedVariables));
this.actualParametersTuple = actualParametersTuple;
this.query = pattern;
}
public PatternCallBasedDeferred(PBody pBody, Tuple actualParametersTuple,
PQuery pattern) {
this(pBody, actualParametersTuple, pattern, Collections.<PVariable> emptySet());
}
private static Set<PVariable> union(Set<PVariable> a, Set<PVariable> b) {
Set<PVariable> result = new HashSet<PVariable>();
result.addAll(a);
result.addAll(b);
return result;
}
@Override
public Set<PVariable> getDeferringVariables() {
if (deferringVariables == null) {
deferringVariables = new HashSet<PVariable>();
for (PVariable var : getCandidateQuantifiedVariables()) {
if (var.isDeducable())
deferringVariables.add(var);
}
}
return deferringVariables;
}
@Override
public void checkSanity() {
super.checkSanity();
for (Object obj : this.actualParametersTuple.getDistinctElements()) {
PVariable var = (PVariable) obj;
if (!getDeferringVariables().contains(var)) {
// so this is a free variable of the NAC / aggregation?
for (PConstraint pConstraint : var.getReferringConstraints()) {
if (pConstraint != this
&& !(pConstraint instanceof Equality && ((Equality) pConstraint).isMoot()))
throw new QueryProcessingException (
"Variable {1} of constraint {2} is not a positively determined part of the pattern, yet it is also affected by {3}.",
new String[] { var.toString(), this.toString(), pConstraint.toString() },
"Read-only variable can not be deduced", null);
}
}
}
}
// public SubPlan getSidePlan(IOperationCompiler compiler) throws QueryPlannerException {
// SubPlan sidePlan = compiler.patternCallPlan(actualParametersTuple, query);
// sidePlan = BuildHelper.enforceVariableCoincidences(compiler, sidePlan);
// return sidePlan;
// }
@Override
protected void doReplaceVariable(PVariable obsolete, PVariable replacement) {
if (deferringVariables != null) {
// FAIL instead of hopeless attempt to fix
// if (deferringVariables.remove(obsolete)) deferringVariables.add(replacement);
throw new IllegalStateException("Cannot replace variables on " + this
+ " when deferring variables have already been identified.");
}
actualParametersTuple = actualParametersTuple.replaceAll(obsolete, replacement);
doDoReplaceVariables(obsolete, replacement);
}
public Tuple getActualParametersTuple() {
return actualParametersTuple;
}
@Override
public PQuery getReferredQuery() {
return query;
}
}
|
