wpds.impl

Class WeightedPAutomaton<N extends Location,D extends State,W extends Weight>

java.lang.Object

wpds.impl.WeightedPAutomaton<N,D,W>

All Implemented Interfaces:

pathexpression.LabeledGraph<D,N>

Direct Known Subclasses:

PAutomaton

public abstract class WeightedPAutomaton<N extends Location,D extends State,W extends Weight>
extends Object
implements pathexpression.LabeledGraph<D,N>

Field Summary

Fields

Modifier and Type	Field and Description
int	failedAdditions
int	failedDirectAdditions
protected Set<D>	finalState
protected D	initialState
protected Set<D>	states
protected Set<Transition<N,D>>	transitions
protected Set<D>	unbalancedStates

Constructor Summary

Constructors

Constructor and Description
WeightedPAutomaton(D initialState)

Method Summary

Modifier and Type	Method and Description
void	addFinalState(D state)
void	addNestedAutomaton(WeightedPAutomaton<N,D,W> nested)
boolean	addTransition(Transition<N,D> trans)
void	addUnbalancedState(D state)
boolean	addWeightForTransition(Transition<N,D> trans, W weight)
void	clearListener()
boolean	containsLoop()
WeightedPAutomaton<N,D,W>	createNestedAutomaton(D initialState)
abstract D	createState(D d, N loc)
abstract N	epsilon()
pathexpression.IRegEx<N>	extractLanguage(D from)
pathexpression.IRegEx<N>	extractLanguage(D from, D to)
Set<pathexpression.Edge<D,N>>	getEdges()
Set<D>	getFinalState()
D	getInitialState()
Set<N>	getLongestPath()
Set<D>	getNodes()
abstract W	getOne()
Set<D>	getStates()
protected Map<D,ForwardDFSVisitor<N,D,W>>	getStateToDFS()
protected Map<D,ForwardDFSVisitor<N,D,W>>	getStateToEpsilonDFS()
Collection<Transition<N,D>>	getTransitions()
Map<Transition<N,D>,W>	getTransitionsToFinalWeights()
W	getWeightFor(Transition<N,D> trans)
abstract W	getZero()
abstract boolean	isGeneratedState(D d)
boolean	isInitialAutomaton(WeightedPAutomaton<N,D,W> aut)
boolean	isUnbalancedState(D target)
boolean	nested()
void	onManyStateListenerRegister()
void	reconnectPush(N callSite, N returnSite, D returnedFact, W returnedWeight)
void	registerConnectPushListener(ConnectPushListener<N,D,W> l)
void	registerDFSEpsilonListener(D state, ReachabilityListener<N,D> l)
void	registerDFSListener(D state, ReachabilityListener<N,D> l)
void	registerListener(WPAStateListener<N,D,W> l)
void	registerListener(WPAUpdateListener<N,D,W> listener)
void	registerNestedAutomatonListener(NestedAutomatonListener<N,D,W> l)
void	registerUnbalancedPopListener(UnbalancedPopListener<N,D,W> l)
void	setInitialAutomaton(WeightedPAutomaton<N,D,W> aut)
String	toDotString()
String	toLabelGroupedDotString()
pathexpression.IRegEx<N>	toRegEx(D start, D end)
String	toString()
void	unbalancedPop(D targetState, Transition<N,D> trans, W weight)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Detail

transitions

protected Set<Transition<N extends Location,D extends State>> transitions

finalState

protected Set<D extends State> finalState

initialState

protected final D extends State initialState

states

protected Set<D extends State> states

failedAdditions

public int failedAdditions

failedDirectAdditions

public int failedDirectAdditions

unbalancedStates

protected Set<D extends State> unbalancedStates

Constructor Detail

WeightedPAutomaton

public WeightedPAutomaton(D initialState)

Method Detail

createState

public abstract D createState(D d,
                              N loc)

isGeneratedState

public abstract boolean isGeneratedState(D d)

getTransitions

public Collection<Transition<N,D>> getTransitions()

addTransition

public boolean addTransition(Transition<N,D> trans)

getInitialState

public D getInitialState()

getFinalState

public Set<D> getFinalState()

toString

public String toString()

Overrides:

toString in class Object

toDotString

public String toDotString()

toLabelGroupedDotString

public String toLabelGroupedDotString()

epsilon

public abstract N epsilon()

extractLanguage

public pathexpression.IRegEx<N> extractLanguage(D from)

extractLanguage

public pathexpression.IRegEx<N> extractLanguage(D from,
                                                D to)

getStates

public Set<D> getStates()

getEdges

public Set<pathexpression.Edge<D,N>> getEdges()

Specified by:

getEdges in interface pathexpression.LabeledGraph<D extends State,N extends Location>

getNodes

public Set<D> getNodes()

Specified by:

getNodes in interface pathexpression.LabeledGraph<D extends State,N extends Location>

addWeightForTransition

public boolean addWeightForTransition(Transition<N,D> trans,
                                      W weight)

getWeightFor

public W getWeightFor(Transition<N,D> trans)

registerListener

public void registerListener(WPAUpdateListener<N,D,W> listener)

onManyStateListenerRegister

public void onManyStateListenerRegister()

registerListener

public void registerListener(WPAStateListener<N,D,W> l)

addFinalState

public void addFinalState(D state)

registerDFSListener

public void registerDFSListener(D state,
                                ReachabilityListener<N,D> l)

getStateToDFS

protected Map<D,ForwardDFSVisitor<N,D,W>> getStateToDFS()

registerDFSEpsilonListener

public void registerDFSEpsilonListener(D state,
                                       ReachabilityListener<N,D> l)

getStateToEpsilonDFS

protected Map<D,ForwardDFSVisitor<N,D,W>> getStateToEpsilonDFS()

getZero

public abstract W getZero()

getOne

public abstract W getOne()

createNestedAutomaton

public WeightedPAutomaton<N,D,W> createNestedAutomaton(D initialState)

reconnectPush

public void reconnectPush(N callSite,
                          N returnSite,
                          D returnedFact,
                          W returnedWeight)

registerConnectPushListener

public void registerConnectPushListener(ConnectPushListener<N,D,W> l)

registerUnbalancedPopListener

public void registerUnbalancedPopListener(UnbalancedPopListener<N,D,W> l)

unbalancedPop

public void unbalancedPop(D targetState,
                          Transition<N,D> trans,
                          W weight)

getTransitionsToFinalWeights

public Map<Transition<N,D>,W> getTransitionsToFinalWeights()

nested

public boolean nested()

addNestedAutomaton

public void addNestedAutomaton(WeightedPAutomaton<N,D,W> nested)

registerNestedAutomatonListener

public void registerNestedAutomatonListener(NestedAutomatonListener<N,D,W> l)

setInitialAutomaton

public void setInitialAutomaton(WeightedPAutomaton<N,D,W> aut)

isInitialAutomaton

public boolean isInitialAutomaton(WeightedPAutomaton<N,D,W> aut)

toRegEx

public pathexpression.IRegEx<N> toRegEx(D start,
                                        D end)

containsLoop

public boolean containsLoop()

getLongestPath

public Set<N> getLongestPath()

isUnbalancedState

public boolean isUnbalancedState(D target)

addUnbalancedState

public void addUnbalancedState(D state)

clearListener

public void clearListener()