/**
* Checks whether its kernel rule is applicable at the specified graph by the specified matching
* strategy or not.
*/
public boolean isApplicable(
final Graph g,
final MorphCompletionStrategy strategy,
final boolean doCheckIfReadyToTransform) {
boolean result = this.enabled;
if (result && doCheckIfReadyToTransform) {
result = this.isReadyToTransform();
}
if (result) {
result = false;
Match m = BaseFactory.theFactory().createMatch(this.kernelRule, g);
if (m != null) {
m.setCompletionStrategy(strategy, true);
m.enableInputParameter(false);
// ((VarTuple) this.getAttrContext().getVariables()).showVariables();
// ((VarTuple) m.getAttrContext().getVariables()).showVariables();
if (m.nextCompletion()) {
result = true;
}
m.dispose();
}
}
return result;
}
/** Create new multi rule with embedding of the kernel rule. */
public MultiRule createMultiRule(final String ruleName) {
OrdinaryMorphism embL = this.kernelRule.getLeft().plainCopy();
if (embL == null) {
embL =
new OrdinaryMorphism(
this.kernelRule.getLeft(),
BaseFactory.theFactory().createGraph(this.kernelRule.getLeft().getTypeSet(), false),
agg.attribute.impl.AttrTupleManager.getDefaultManager()
.newContext(AttrMapping.PLAIN_MAP));
}
OrdinaryMorphism embR = this.kernelRule.getRight().plainCopy();
if (embR == null) {
embR =
new OrdinaryMorphism(
this.kernelRule.getRight(),
BaseFactory.theFactory().createGraph(this.kernelRule.getRight().getTypeSet(), false),
agg.attribute.impl.AttrTupleManager.getDefaultManager()
.newContext(AttrMapping.PLAIN_MAP));
}
MultiRule multiRule = new MultiRule(this.kernelRule, embL, embR);
// add only variables of LHS and RHS
if (this.kernelRule.hasNACs() || this.kernelRule.hasPACs()) {
final Vector<String> list = this.kernelRule.getLeft().getVariableNamesOfAttributes();
list.addAll(this.kernelRule.getRight().getVariableNamesOfAttributes());
multiRule.addToAttrContextAccordingList(
(VarTuple) this.kernelRule.getAttrContext().getVariables(), list);
} else {
multiRule.addToAttrContext((VarTuple) this.kernelRule.getAttrContext().getVariables());
}
multiRule.setRuleScheme(this);
multiRule.setName(ruleName);
multiRule.getLeft().setKind(GraphKind.LHS);
multiRule.getRight().setKind(GraphKind.RHS);
this.multiRules.add(multiRule);
this.kernelRule.getLeft().addObserver(multiRule);
this.kernelRule.getRight().addObserver(multiRule);
this.kernelRule.addObserver(multiRule);
this.kernelRule.setChanged(false);
return multiRule;
}
/**
* Shift the specified application condition (NAC / PAC / General AC) along the specified
* embedding morphism. Required:<br>
* cond.getSource() == embedding.getSource()<br>
* Result morphism:<br>
* embedding.getTarget() -> copy of cond.getSource()
*
* @param cond an application condition
* @param morph an embedding morphism
* @return shifted application condition, Returns null if shifting failed.
*/
private OrdinaryMorphism shiftApplCondAlongMorph(
final OrdinaryMorphism cond, final OrdinaryMorphism morph) {
if (cond.getSource() == morph.getSource()) {
final OrdinaryMorphism condIso = cond.getTarget().isomorphicCopy();
if (condIso == null) return null;
final OrdinaryMorphism shiftCond =
(cond instanceof NestedApplCond)
? BaseFactory.theFactory()
.createGeneralMorphism(morph.getTarget(), condIso.getTarget())
: BaseFactory.theFactory().createMorphism(morph.getTarget(), condIso.getTarget());
final Enumeration<GraphObject> condDom = cond.getDomain();
while (condDom.hasMoreElements()) {
GraphObject go = condDom.nextElement();
GraphObject condImg = cond.getImage(go);
if (condImg != null) {
GraphObject embedImg = morph.getImage(go);
GraphObject isoImg = condIso.getImage(condImg);
if (embedImg != null && isoImg != null) {
try {
shiftCond.addMapping(embedImg, isoImg);
} catch (BadMappingException ex) {
shiftCond.dispose();
condIso.dispose(false, true);
return null;
}
} else {
shiftCond.dispose();
condIso.dispose(false, true);
return null;
}
}
}
return shiftCond;
}
return null;
}
/** Returns a copy of this rule scheme by using the specified types. */
public RuleScheme getClone(TypeSet types) {
return BaseFactory.theFactory().cloneRuleScheme(this, types);
}
/** Returns a copy of this rule scheme by using its types. */
public RuleScheme getClone() {
return BaseFactory.theFactory().cloneRuleScheme(this);
}
/**
* Creates if needed a match of the kernel rule.
*
* @param graph host graph to apply the kernel rule
* @return match of the kernel rule
*/
public Match getKernelMatch(final Graph graph) {
if (this.kernelRule.getMatch() == null) {
this.kernelRule.setMatch(BaseFactory.theFactory().createMatch(this.kernelRule, graph));
}
return this.kernelRule.getMatch();
}
/**
* Reads the contents of a xml file to restore this object.
*
* @param h A helper object for loading.
*/
public void XreadObject(XMLHelper h) {
if (h.isTag("CriticalPairs", this)) {
// System.out.println("LayerExcludePairContainer.XreadObject ...");
Rule r1 = null;
Rule r2 = null;
boolean b = false;
Vector<
Pair<
Pair<OrdinaryMorphism, OrdinaryMorphism>,
Pair<OrdinaryMorphism, OrdinaryMorphism>>>
allOverlappings = null;
Vector<String> tagnames = new Vector<String>(1);
Vector<String> tagnames2 = new Vector<String>(1);
this.grammar = BaseFactory.theFactory().createGraGra();
h.getObject("", this.grammar, true);
tagnames.add("conflictContainer");
tagnames.add("conflictsContainer");
tagnames.add("excludeContainer");
tagnames2.add("dependencyContainer");
tagnames2.add("dependenciesContainer");
this.switchDependency = false;
if (h.readSubTag(tagnames2)) {
this.conflictKind = CriticalPair.TRIGGER_DEPENDENCY;
if (h.readAttr("kind").equals("trigger_switch_dependency")) {
this.switchDependency = true;
this.conflictKind = CriticalPair.TRIGGER_SWITCH_DEPENDENCY;
}
} else if (h.readSubTag(tagnames)) {
this.conflictKind = CriticalPair.CONFLICT;
}
if (this.conflictKind == CriticalPair.TRIGGER_DEPENDENCY
|| this.conflictKind == CriticalPair.TRIGGER_SWITCH_DEPENDENCY
|| this.conflictKind == CriticalPair.CONFLICT) {
Enumeration<?> r1s = h.getEnumeration("", null, true, "Rule");
if (!r1s.hasMoreElements()) r1s = h.getEnumeration("", null, true, "Regel");
while (r1s.hasMoreElements()) {
h.peekElement(r1s.nextElement());
/*
* da ein referenziertes object geholt werden soll. muss nur
* angegeben werden wie der Membername heisst.
*/
r1 = (Rule) h.getObject("R1", null, false);
Enumeration<?> r2s = h.getEnumeration("", null, true, "Rule");
if (!r2s.hasMoreElements()) r2s = h.getEnumeration("", null, true, "Regel");
while (r2s.hasMoreElements()) {
h.peekElement(r2s.nextElement());
r2 = (Rule) h.getObject("R2", null, false);
String bool = h.readAttr("bool");
allOverlappings = null;
b = false;
if (bool.equals("true")) {
b = true;
allOverlappings =
new Vector<
Pair<
Pair<OrdinaryMorphism, OrdinaryMorphism>,
Pair<OrdinaryMorphism, OrdinaryMorphism>>>();
Enumeration<?> overlappings = h.getEnumeration("", null, true, "Overlapping_Pair");
while (overlappings.hasMoreElements()) {
h.peekElement(overlappings.nextElement());
Graph g = (Graph) h.getObject("", new Graph(), true);
while (h.readSubTag("Critical")) {
GraphObject o = (GraphObject) h.getObject("object", null, false);
if (o != null) o.setCritical(true);
h.close();
}
/*
* OrdinaryMorphism first =
* BaseFactory.theFactory().createMorphism(r1.getRight(),g);
* first.readMorphism(h); OrdinaryMorphism
* second =
* BaseFactory.theFactory().createMorphism(r2.getLeft(),g);
* second.readMorphism(h);
* allOverlappings.addElement(new
* Pair(first,second));
*/
Pair<
Pair<OrdinaryMorphism, OrdinaryMorphism>,
Pair<OrdinaryMorphism, OrdinaryMorphism>>
p = readOverlappingMorphisms(h, r1, r2, g);
allOverlappings.addElement(p);
h.close();
}
}
addQuadruple(this.excludeContainer, r1, r2, b, allOverlappings);
h.close();
}
h.close();
}
h.close();
// System.out.println("excludeContainer
// "+excludeContainer+"\n");
} /* Ende readSubTag("excludeContainer") */
if (h.readSubTag("conflictFreeContainer")) {
Enumeration<?> r1s = h.getEnumeration("", null, true, "Rule");
if (!r1s.hasMoreElements()) r1s = h.getEnumeration("", null, true, "Regel");
while (r1s.hasMoreElements()) {
h.peekElement(r1s.nextElement());
/*
* da ein referenziertes object geholt werden soll. muss nur
* angegeben werden wie der Membername heisst.
*/
r1 = (Rule) h.getObject("R1", null, false);
Enumeration<?> r2s = h.getEnumeration("", null, true, "Rule");
if (!r2s.hasMoreElements()) r2s = h.getEnumeration("", null, true, "Regel");
while (r2s.hasMoreElements()) {
h.peekElement(r2s.nextElement());
r2 = (Rule) h.getObject("R2", null, false);
String bool = h.readAttr("bool");
b = false;
if (bool.equals("true")) b = true;
addQuadruple(this.conflictFreeContainer, r1, r2, b, null);
if (!r1.isEnabled()) // test disabled rule
this.getEntry(r1, r2).state = Entry.DISABLED;
else if (r1.getLayer() != r2.getLayer()) // test rule
// layer
this.getEntry(r1, r2).state = Entry.NOT_RELATED;
h.close();
}
h.close();
}
h.close();
// System.out.println("conflictFreeContainer
// "+conflictFreeContainer+"\n");
}
}
// isComputed = true;
h.close();
}
