|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Objectagg.parser.ExcludePairContainer
public class ExcludePairContainer
This Container contains only conflict free and exclude relations.
Nested Class Summary | |
---|---|
class |
ExcludePairContainer.Entry
|
Field Summary | |
---|---|
protected boolean |
asymmetrically
|
protected boolean |
calculateParallel
true, if each calculation should be done in an extra Thread. |
java.util.Hashtable<Rule,java.util.Hashtable<Rule,ExcludePairContainer.Entry>> |
commonContainer
Contains for each Pair one Entry. |
protected boolean |
complete
|
protected java.util.Hashtable<Rule,java.util.Hashtable<Rule,Pair<java.lang.Boolean,java.util.Vector<Pair<Pair<OrdinaryMorphism,OrdinaryMorphism>,Pair<OrdinaryMorphism,OrdinaryMorphism>>>>>> |
conflictFreeContainer
This container stores the conflict free relations. |
protected int |
conflictKind
|
protected boolean |
consistent
|
protected boolean |
equalVariableNameOfAttrMapping
|
protected java.util.Hashtable<Rule,java.util.Hashtable<Rule,Pair<java.lang.Boolean,java.util.Vector<Pair<Pair<OrdinaryMorphism,OrdinaryMorphism>,Pair<OrdinaryMorphism,OrdinaryMorphism>>>>>> |
excludeContainer
This container stores the conflict relations. |
protected java.util.Hashtable<Graph,java.util.Vector<java.util.Hashtable<GraphObject,GraphObject>>> |
excludeContainerForTestGraph
|
protected ExcludePair |
excludePair
|
protected GraGra |
grammar
The graph grammar |
protected boolean |
ignoreIdenticalRules
|
protected boolean |
isAlive
true if global generating process is running. |
protected boolean |
isComputed
true if all the relations are computed. |
protected boolean |
isComputedLocal
true if one pair relations are computed. |
protected boolean |
isEmpty
|
protected java.util.Vector<ParserEventListener> |
listener
|
protected boolean |
reduce
|
protected boolean |
reduceSameMatch
|
protected java.util.List<Rule> |
rules
|
protected boolean |
stop
true if global generating process will be stopped |
protected MorphCompletionStrategy |
strategy
|
protected boolean |
strongAttrCheck
|
protected Graph |
testGraph
|
protected boolean |
useHostGraph
|
protected boolean |
withNACs
|
protected boolean |
withPACs
|
Constructor Summary | |
---|---|
ExcludePairContainer(GraGra gragra)
Creates a new container for critical pairs. |
Method Summary | |
---|---|
protected ExcludePairContainer.Entry |
addEntry(Rule r1,
Rule r2,
boolean critical,
java.util.Vector<Pair<Pair<OrdinaryMorphism,OrdinaryMorphism>,Pair<OrdinaryMorphism,OrdinaryMorphism>>> overlapping)
|
void |
addPairEventListener(ParserEventListener l)
Adds a PairEventListener. |
protected void |
addQuadruple(java.util.Hashtable<Rule,java.util.Hashtable<Rule,Pair<java.lang.Boolean,java.util.Vector<Pair<Pair<OrdinaryMorphism,OrdinaryMorphism>,Pair<OrdinaryMorphism,OrdinaryMorphism>>>>>> container,
Rule r1,
Rule r2,
boolean critic,
java.util.Vector<Pair<Pair<OrdinaryMorphism,OrdinaryMorphism>,Pair<OrdinaryMorphism,OrdinaryMorphism>>> overlapping)
Adds four important data to a container. |
void |
checkConsistency()
|
protected boolean |
checkCritical(Rule r1,
Rule r2,
Graph testgraph)
|
void |
clear()
Clears the rule pair containers. |
void |
clearEntry(Rule r1,
Rule r2)
|
protected void |
computeCritical(Rule r1,
Rule r2)
Computes if the first rule exclude the second rule. |
protected boolean |
computeCritical(Rule r1,
Rule r2,
Graph g)
|
void |
enableComplete(boolean enable)
|
void |
enableConsistent(boolean enable)
|
void |
enableEqualVariableNameOfAttrMapping(boolean enable)
|
void |
enableIgnoreIdenticalRules(boolean b)
|
void |
enableNACs(boolean enable)
Deprecated. replaced by setMorphismCompletionStrategy(MorphCompletionStrategy strat) |
void |
enablePACs(boolean enable)
|
void |
enableReduce(boolean enable)
|
void |
enableReduceSameMatch(boolean enable)
|
void |
enableStrongAttrCheck(boolean enable)
|
void |
enableUseHostGraph(boolean enable,
Graph g)
|
void |
enableUseHostGraph(boolean enable,
Graph g,
MorphCompletionStrategy strat)
|
protected void |
fillContainers()
Fills all containers with the critical pairs. |
protected void |
fillContainers(java.util.List<Rule> ruleList,
boolean asymmetrical)
|
protected void |
fillContainers(Rule r1,
Rule r2)
Fills all containers with the critical pairs. |
protected void |
firePairEvent(ParserEvent event)
Sends a event to all its listeners. |
ExcludePair |
getActiveExcludePair()
|
java.util.Hashtable<Rule,java.util.Hashtable<Rule,Pair<java.lang.Boolean,java.util.Vector<Pair<Pair<OrdinaryMorphism,OrdinaryMorphism>,Pair<OrdinaryMorphism,OrdinaryMorphism>>>>>> |
getConflictContainer()
|
java.util.Hashtable<Rule,java.util.Hashtable<Rule,Pair<java.lang.Boolean,java.util.Vector<Pair<Pair<OrdinaryMorphism,OrdinaryMorphism>,Pair<OrdinaryMorphism,OrdinaryMorphism>>>>>> |
getConflictFreeContainer()
|
java.util.Hashtable<Rule,java.util.Hashtable<Rule,Pair<java.lang.Boolean,java.util.Vector<Pair<Pair<OrdinaryMorphism,OrdinaryMorphism>,Pair<OrdinaryMorphism,OrdinaryMorphism>>>>>> |
getContainer(int kind)
This container is a Hashtable with a rule as key. |
java.util.Hashtable<Rule,java.util.Hashtable<Rule,Pair<java.lang.Boolean,java.util.Vector<Pair<Pair<OrdinaryMorphism,OrdinaryMorphism>,Pair<OrdinaryMorphism,OrdinaryMorphism>>>>>> |
getContainer(int kind,
java.util.List<Rule> ruleList,
boolean asymmetrical)
|
java.util.Hashtable<Rule,java.util.Hashtable<Rule,Pair<java.lang.Boolean,java.util.Vector<Pair<Pair<OrdinaryMorphism,OrdinaryMorphism>,Pair<OrdinaryMorphism,OrdinaryMorphism>>>>>> |
getContainer(int kind,
Rule r1,
Rule r2)
|
java.lang.Object |
getCritical(Rule r1,
Rule r2,
int kind)
Deprecated. replaced by getCriticalPair(Rule r1, Rule r2, int kind) |
java.lang.Object |
getCritical(Rule r1,
Rule r2,
int kind,
boolean local)
Deprecated. replaced by getCriticalPair(Rule r1, Rule r2, int kind, boolean local) |
java.util.Hashtable<Graph,java.util.Vector<java.util.Hashtable<GraphObject,GraphObject>>> |
getCriticalForGraph(Rule r1,
Rule r2)
|
java.util.Hashtable<Graph,java.util.Vector<java.util.Hashtable<GraphObject,GraphObject>>> |
getCriticalForGraph(Rule r1,
Rule r2,
Graph g)
Computes the critical part of two rules and checks it on the specified Graph g. |
protected java.util.Vector<Pair<Pair<OrdinaryMorphism,OrdinaryMorphism>,Pair<OrdinaryMorphism,OrdinaryMorphism>>> |
getCriticalPair(Rule r1,
Rule r2,
java.util.Hashtable<Rule,java.util.Hashtable<Rule,Pair<java.lang.Boolean,java.util.Vector<Pair<Pair<OrdinaryMorphism,OrdinaryMorphism>,Pair<OrdinaryMorphism,OrdinaryMorphism>>>>>> container)
Returns the critical object of two rules. |
java.util.Vector<Pair<Pair<OrdinaryMorphism,OrdinaryMorphism>,Pair<OrdinaryMorphism,OrdinaryMorphism>>> |
getCriticalPair(Rule r1,
Rule r2,
int kind)
computes the critical part of two rules. |
java.util.Vector<Pair<Pair<OrdinaryMorphism,OrdinaryMorphism>,Pair<OrdinaryMorphism,OrdinaryMorphism>>> |
getCriticalPair(Rule r1,
Rule r2,
int kind,
boolean local)
|
java.util.Vector<Pair<java.util.Hashtable<GraphObject,GraphObject>,java.util.Hashtable<GraphObject,GraphObject>>> |
getCriticalPairAtGraph(Rule r1,
Rule r2)
|
java.util.Vector<Pair<Pair<OrdinaryMorphism,OrdinaryMorphism>,Pair<OrdinaryMorphism,OrdinaryMorphism>>> |
getCriticalSet(int kind,
Rule rule)
This method computes which rules are in a relation of a special kind. |
ExcludePairContainer.Entry |
getEntry(Rule r1,
Rule r2)
|
ExcludePairContainer.Entry |
getEntry(Rule r1,
Rule r2,
boolean alreadyExistent)
|
java.util.Hashtable<Rule,java.util.Hashtable<Rule,Pair<java.lang.Boolean,java.util.Vector<Pair<Pair<OrdinaryMorphism,OrdinaryMorphism>,Pair<OrdinaryMorphism,OrdinaryMorphism>>>>>> |
getExcludeContainer()
|
java.util.Hashtable<Graph,java.util.Vector<java.util.Hashtable<GraphObject,GraphObject>>> |
getExcludeContainerForTestGraph()
|
GraGra |
getGrammar()
Returns the graph grammar of the critical pairs. |
int |
getKindOfConflict()
Returns CriticalPair.CONFLICT or CriticalPair.DEPENDENCY constant. |
LayerFunction |
getLayer()
Deprecated. |
java.util.Vector<Pair<OrdinaryMorphism,OrdinaryMorphism>> |
getLHSoverlappings(Rule r1,
Rule r2,
java.util.Vector<Pair<Pair<OrdinaryMorphism,OrdinaryMorphism>,Pair<OrdinaryMorphism,OrdinaryMorphism>>> criticalPairs)
|
MorphCompletionStrategy |
getMorphCompletionStrategy()
|
int |
getNumberOfContainers()
Returns the number of containers. |
java.util.List<Rule> |
getRules()
|
int |
getState(Rule r1,
Rule r2)
return if this pair of rules is already computed. |
void |
initAllContainer()
Initials all containers. |
boolean |
isAlive()
|
boolean |
isComputed()
|
boolean |
isEmpty()
|
protected void |
moveEntryFromExcludeToConflictFreeContainer(Rule r1,
Rule r2)
|
protected Pair<OrdinaryMorphism,OrdinaryMorphism> |
readOldOverlappingMorphisms(XMLHelper h,
Rule r1,
Rule r2,
java.lang.String firstName,
Graph overlapGraph)
|
protected Pair<Pair<OrdinaryMorphism,OrdinaryMorphism>,Pair<OrdinaryMorphism,OrdinaryMorphism>> |
readOverlappingMorphisms(XMLHelper h,
Rule r1,
Rule r2,
Graph overlapGraph)
|
boolean |
reduceCriticalPairs()
|
protected void |
removeEntryFromExcludeContainer(Rule r1,
Rule r2)
|
void |
removePairEventListener(ParserEventListener l)
Removes a PairEventListener |
void |
run()
Starts the filling of all containers parallel. |
protected void |
scheduleForComputing(Rule r1,
Rule r2)
|
void |
setComputeAsymetrically(boolean b)
|
void |
setEntryRelationVisible(Rule rule1,
Rule rule2,
boolean vis,
boolean local)
|
void |
setEntryRuleVisible(Rule rule1,
Rule rule2,
boolean vis,
boolean local,
boolean context)
|
void |
setGrammar(GraGra gragra)
Sets the graph grammar for the critical pairs. |
void |
setMorphCompletionStrategy(MorphCompletionStrategy strat)
|
void |
setRules(java.util.List<Rule> ruleList)
|
void |
setStop(boolean b)
|
void |
stop()
Stops the running. |
java.lang.String |
toString()
Provides a human readable text of the critical pairs. |
boolean |
useHostGraphEnabled()
|
boolean |
wasStopped()
|
protected void |
writeOverlapMorphisms(XMLHelper h,
Rule r1,
Rule r2,
Pair<Pair<OrdinaryMorphism,OrdinaryMorphism>,Pair<OrdinaryMorphism,OrdinaryMorphism>> overlapping)
|
void |
XreadObject(XMLHelper h)
Reads the contents of a xml file to restore this object. |
void |
XwriteObject(XMLHelper h)
Writes the contents of this object to a file in a xml format. |
Methods inherited from class java.lang.Object |
---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait |
Field Detail |
---|
protected java.util.Hashtable<Rule,java.util.Hashtable<Rule,Pair<java.lang.Boolean,java.util.Vector<Pair<Pair<OrdinaryMorphism,OrdinaryMorphism>,Pair<OrdinaryMorphism,OrdinaryMorphism>>>>>> excludeContainer
protected boolean calculateParallel
protected java.util.Hashtable<Rule,java.util.Hashtable<Rule,Pair<java.lang.Boolean,java.util.Vector<Pair<Pair<OrdinaryMorphism,OrdinaryMorphism>,Pair<OrdinaryMorphism,OrdinaryMorphism>>>>>> conflictFreeContainer
public java.util.Hashtable<Rule,java.util.Hashtable<Rule,ExcludePairContainer.Entry>> commonContainer
protected int conflictKind
protected GraGra grammar
protected java.util.List<Rule> rules
protected boolean asymmetrically
protected boolean isComputed
protected boolean isComputedLocal
protected final java.util.Vector<ParserEventListener> listener
protected boolean stop
protected boolean isAlive
protected ExcludePair excludePair
protected boolean complete
protected boolean reduce
protected boolean reduceSameMatch
protected boolean withNACs
protected boolean withPACs
protected boolean consistent
protected boolean strongAttrCheck
protected boolean equalVariableNameOfAttrMapping
protected boolean useHostGraph
protected final java.util.Hashtable<Graph,java.util.Vector<java.util.Hashtable<GraphObject,GraphObject>>> excludeContainerForTestGraph
protected Graph testGraph
protected MorphCompletionStrategy strategy
protected boolean isEmpty
protected boolean ignoreIdenticalRules
Constructor Detail |
---|
public ExcludePairContainer(GraGra gragra)
gragra
- The graph grammar.Method Detail |
---|
public ExcludePair getActiveExcludePair()
getActiveExcludePair
in interface PairContainer
public void run()
run
in interface java.lang.Runnable
public void stop()
stop
in interface PairContainer
public void setStop(boolean b)
setStop
in interface PairContainer
public boolean wasStopped()
wasStopped
in interface PairContainer
public void enableIgnoreIdenticalRules(boolean b)
public java.util.Vector<Pair<Pair<OrdinaryMorphism,OrdinaryMorphism>,Pair<OrdinaryMorphism,OrdinaryMorphism>>> getCriticalPair(Rule r1, Rule r2, int kind) throws InvalidAlgorithmException
Vector
of overlaping graphs.
getCriticalPair
in interface PairContainer
r1
- The first part of a critical pairr2
- The second part of a critical pairkind
- The kind of critical pair
InvalidAlgorithmException
- Thrown if a illegal algorithm is chosen.public java.lang.Object getCritical(Rule r1, Rule r2, int kind) throws InvalidAlgorithmException
getCriticalPair(Rule r1, Rule r2, int kind)
getCritical
in interface PairContainer
InvalidAlgorithmException
public java.lang.Object getCritical(Rule r1, Rule r2, int kind, boolean local) throws InvalidAlgorithmException
getCriticalPair(Rule r1, Rule r2, int kind, boolean local)
InvalidAlgorithmException
public java.util.Vector<Pair<Pair<OrdinaryMorphism,OrdinaryMorphism>,Pair<OrdinaryMorphism,OrdinaryMorphism>>> getCriticalPair(Rule r1, Rule r2, int kind, boolean local) throws InvalidAlgorithmException
getCriticalPair
in interface PairContainer
InvalidAlgorithmException
public java.util.Hashtable<Graph,java.util.Vector<java.util.Hashtable<GraphObject,GraphObject>>> getCriticalForGraph(Rule r1, Rule r2, Graph g)
r1
- The first part of a critical pairr2
- The second part of a critical pairg
- The graph on which these two rules should be checked
Hashtable>>
,
where a Graph is an overlapping graph and is a key, a Vectorpublic java.util.Vector<Pair<java.util.Hashtable<GraphObject,GraphObject>,java.util.Hashtable<GraphObject,GraphObject>>> getCriticalPairAtGraph(Rule r1, Rule r2)
public java.util.Hashtable<Graph,java.util.Vector<java.util.Hashtable<GraphObject,GraphObject>>> getCriticalForGraph(Rule r1, Rule r2)
protected java.util.Vector<Pair<Pair<OrdinaryMorphism,OrdinaryMorphism>,Pair<OrdinaryMorphism,OrdinaryMorphism>>> getCriticalPair(Rule r1, Rule r2, java.util.Hashtable<Rule,java.util.Hashtable<Rule,Pair<java.lang.Boolean,java.util.Vector<Pair<Pair<OrdinaryMorphism,OrdinaryMorphism>,Pair<OrdinaryMorphism,OrdinaryMorphism>>>>>> container)
r1
- The first ruler2
- The second rulecontainer
- The container.
public java.util.Vector<Pair<OrdinaryMorphism,OrdinaryMorphism>> getLHSoverlappings(Rule r1, Rule r2, java.util.Vector<Pair<Pair<OrdinaryMorphism,OrdinaryMorphism>,Pair<OrdinaryMorphism,OrdinaryMorphism>>> criticalPairs)
public int getNumberOfContainers()
getNumberOfContainers
in interface PairContainer
public java.util.Hashtable<Rule,java.util.Hashtable<Rule,Pair<java.lang.Boolean,java.util.Vector<Pair<Pair<OrdinaryMorphism,OrdinaryMorphism>,Pair<OrdinaryMorphism,OrdinaryMorphism>>>>>> getExcludeContainer()
public java.util.Hashtable<Rule,java.util.Hashtable<Rule,Pair<java.lang.Boolean,java.util.Vector<Pair<Pair<OrdinaryMorphism,OrdinaryMorphism>,Pair<OrdinaryMorphism,OrdinaryMorphism>>>>>> getConflictContainer()
public java.util.Hashtable<Rule,java.util.Hashtable<Rule,Pair<java.lang.Boolean,java.util.Vector<Pair<Pair<OrdinaryMorphism,OrdinaryMorphism>,Pair<OrdinaryMorphism,OrdinaryMorphism>>>>>> getConflictFreeContainer()
public java.util.Hashtable<Rule,java.util.Hashtable<Rule,Pair<java.lang.Boolean,java.util.Vector<Pair<Pair<OrdinaryMorphism,OrdinaryMorphism>,Pair<OrdinaryMorphism,OrdinaryMorphism>>>>>> getContainer(int kind) throws InvalidAlgorithmException
Hashtable
with a rule as key. The
value will be a set of rules.
getContainer
in interface PairContainer
kind
- The desired algorithm
InvalidAlgorithmException
- Thrown if a illegal algorithm is choosenpublic java.util.Hashtable<Rule,java.util.Hashtable<Rule,Pair<java.lang.Boolean,java.util.Vector<Pair<Pair<OrdinaryMorphism,OrdinaryMorphism>,Pair<OrdinaryMorphism,OrdinaryMorphism>>>>>> getContainer(int kind, java.util.List<Rule> ruleList, boolean asymmetrical) throws InvalidAlgorithmException
InvalidAlgorithmException
public java.util.Hashtable<Rule,java.util.Hashtable<Rule,Pair<java.lang.Boolean,java.util.Vector<Pair<Pair<OrdinaryMorphism,OrdinaryMorphism>,Pair<OrdinaryMorphism,OrdinaryMorphism>>>>>> getContainer(int kind, Rule r1, Rule r2) throws InvalidAlgorithmException
InvalidAlgorithmException
public java.util.Vector<Pair<Pair<OrdinaryMorphism,OrdinaryMorphism>,Pair<OrdinaryMorphism,OrdinaryMorphism>>> getCriticalSet(int kind, Rule rule) throws InvalidAlgorithmException
getCriticalSet
in interface PairContainer
kind
- The kind of critical pairrule
- The rule which is the first part of a critical pair
InvalidAlgorithmException
- Thrown if a illegal algorithm is chosenpublic void setGrammar(GraGra gragra)
setGrammar
in interface PairContainer
gragra
- The graph grammarpublic GraGra getGrammar()
getGrammar
in interface PairContainer
public void setRules(java.util.List<Rule> ruleList)
setRules
in interface PairContainer
public java.util.List<Rule> getRules()
getRules
in interface PairContainer
public void setComputeAsymetrically(boolean b)
setComputeAsymetrically
in interface PairContainer
public void setMorphCompletionStrategy(MorphCompletionStrategy strat)
setMorphCompletionStrategy
in interface PairContainer
public MorphCompletionStrategy getMorphCompletionStrategy()
getMorphCompletionStrategy
in interface PairContainer
public void initAllContainer()
initAllContainer
in interface PairContainer
protected void fillContainers()
protected void fillContainers(java.util.List<Rule> ruleList, boolean asymmetrical)
protected void scheduleForComputing(Rule r1, Rule r2)
protected void fillContainers(Rule r1, Rule r2)
protected void computeCritical(Rule r1, Rule r2)
r1
- The first rule.r2
- The second rule.protected boolean computeCritical(Rule r1, Rule r2, Graph g)
protected void addQuadruple(java.util.Hashtable<Rule,java.util.Hashtable<Rule,Pair<java.lang.Boolean,java.util.Vector<Pair<Pair<OrdinaryMorphism,OrdinaryMorphism>,Pair<OrdinaryMorphism,OrdinaryMorphism>>>>>> container, Rule r1, Rule r2, boolean critic, java.util.Vector<Pair<Pair<OrdinaryMorphism,OrdinaryMorphism>,Pair<OrdinaryMorphism,OrdinaryMorphism>>> overlapping)
container
- The container the data are forr1
- The first ruler2
- The seconf rulecritic
- true if the first rule excludes the second rule.overlapping
- The set of overlapping graphs of the first and second rule.protected ExcludePairContainer.Entry addEntry(Rule r1, Rule r2, boolean critical, java.util.Vector<Pair<Pair<OrdinaryMorphism,OrdinaryMorphism>,Pair<OrdinaryMorphism,OrdinaryMorphism>>> overlapping)
public ExcludePairContainer.Entry getEntry(Rule r1, Rule r2)
public ExcludePairContainer.Entry getEntry(Rule r1, Rule r2, boolean alreadyExistent)
public void clearEntry(Rule r1, Rule r2)
public void setEntryRelationVisible(Rule rule1, Rule rule2, boolean vis, boolean local)
public void setEntryRuleVisible(Rule rule1, Rule rule2, boolean vis, boolean local, boolean context)
public int getState(Rule r1, Rule r2)
public boolean reduceCriticalPairs()
public void checkConsistency()
protected void moveEntryFromExcludeToConflictFreeContainer(Rule r1, Rule r2)
protected void removeEntryFromExcludeContainer(Rule r1, Rule r2)
protected boolean checkCritical(Rule r1, Rule r2, Graph testgraph)
public java.util.Hashtable<Graph,java.util.Vector<java.util.Hashtable<GraphObject,GraphObject>>> getExcludeContainerForTestGraph()
public void clear()
clear
in interface PairContainer
protected void writeOverlapMorphisms(XMLHelper h, Rule r1, Rule r2, Pair<Pair<OrdinaryMorphism,OrdinaryMorphism>,Pair<OrdinaryMorphism,OrdinaryMorphism>> overlapping)
protected Pair<OrdinaryMorphism,OrdinaryMorphism> readOldOverlappingMorphisms(XMLHelper h, Rule r1, Rule r2, java.lang.String firstName, Graph overlapGraph)
protected Pair<Pair<OrdinaryMorphism,OrdinaryMorphism>,Pair<OrdinaryMorphism,OrdinaryMorphism>> readOverlappingMorphisms(XMLHelper h, Rule r1, Rule r2, Graph overlapGraph)
public void XwriteObject(XMLHelper h)
XwriteObject
in interface XMLObject
h
- A helper object for storing.public void XreadObject(XMLHelper h)
XreadObject
in interface XMLObject
h
- A helper object for loading.public java.lang.String toString()
toString
in class java.lang.Object
public boolean isEmpty()
isEmpty
in interface PairContainer
public boolean isComputed()
isComputed
in interface PairContainer
public boolean isAlive()
isAlive
in interface PairContainer
public void addPairEventListener(ParserEventListener l)
addPairEventListener
in interface PairContainer
l
- The listener.public void removePairEventListener(ParserEventListener l)
l
- The listener.protected void firePairEvent(ParserEvent event)
event
- The event which will be sentpublic void enableComplete(boolean enable)
public void enableReduce(boolean enable)
public void enableReduceSameMatch(boolean enable)
public void enableNACs(boolean enable)
withNACs = strategy.getProperties().get(CompletionPropertyBits.NAC);
public void enablePACs(boolean enable)
public void enableConsistent(boolean enable)
public void enableStrongAttrCheck(boolean enable)
public void enableEqualVariableNameOfAttrMapping(boolean enable)
public void enableUseHostGraph(boolean enable, Graph g, MorphCompletionStrategy strat)
public void enableUseHostGraph(boolean enable, Graph g)
enableUseHostGraph
in interface PairContainer
public boolean useHostGraphEnabled()
useHostGraphEnabled
in interface PairContainer
public int getKindOfConflict()
PairContainer
getKindOfConflict
in interface PairContainer
public LayerFunction getLayer()
getLayer
in interface PairContainer
PairContainer.getLayer()
|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |