Uses of Interface
edu.toronto.cs.ctl.CTLNode

Packages that use CTLNode
edu.toronto.cs.ctl CTL Abstract Syntax Tree 
edu.toronto.cs.ctl.antlr ANTLR parser for CTL 
edu.toronto.cs.gclang.parser ANTLR parser for GCLang 
edu.toronto.cs.gui Graphical Interaface to XChek multi-valued model-checker 
edu.toronto.cs.modelchecker Basic CTL model-checking engine based on MvSet 
edu.toronto.cs.proof Provides classes for representing, manipulating, and constructing proofs for CTL formulas (OLD) 
edu.toronto.cs.proof2 Provides classes for representing, manipulating, and constructing proofs for CTL formulas (NEW) 
edu.toronto.cs.simulator A model simulator for XChek (Victor). 
edu.toronto.cs.smv Provides classes to represent SMV models 
edu.toronto.cs.tlq Classes used by TLQSolver extension of XChek 
 

Uses of CTLNode in edu.toronto.cs.ctl
 

Classes in edu.toronto.cs.ctl that implement CTLNode
 class CTLAbstractNode
          This is an abstract CTL node.
 class CTLAFNode
          This is an AF CTL node.
 class CTLAGNode
          This is an AG CTL node.
 class CTLAndNode
          This is an And CTL node.
 class CTLARNode
          This is a universal strong until CTL node.
 class CTLAtomPropNode
          This is an atomic CTL node.
 class CTLAUiNode
          This is a universal strong until CTL node.
 class CTLAUNode
          This is a universal strong until CTL node.
 class CTLAWNode
          This is a universal strong until CTL node.
 class CTLAXNode
          This is an AX CTL node.
 class CTLBinaryNode
           
 class CTLConstantNode
          This is a CTL node representing a lattice value.
 class CTLEFNode
          This is an EF CTL node.
 class CTLEGNode
          This is an EG CTL node.
 class CTLEqualsNode
          This is an Equals CTL node.
 class CTLERNode
          This is a universal strong until CTL node.
 class CTLEUiNode
          This is an existential strong until CTL node.
 class CTLEUNode
          This is an existential strong until CTL node.
 class CTLEWNode
          This is a universal strong until CTL node.
 class CTLEXNode
          This is an EX CTL node.
 class CTLIffNode
          This is an Equivalence CTL node.
 class CTLImplNode
          This is an Implication CTL node.
 class CTLLeafNode
           
 class CTLMvSetNode
          This is a CTL node representing an MvSet.
 class CTLNegNode
          This is a Neg CTL node.
 class CTLOrNode
          This is an Or CTL node.
 class CTLOverNode
          This is an Over CTL node.
 class CTLPlaceholderNode
           
 class CTLPreEXNode
          This is a pre EX CTL node thing.
 class CTLTransitionNode
           
 class CTLUnaryNode
           
 class CTLUnderNode
          This is an Under CTL node.
 

Fields in edu.toronto.cs.ctl declared as CTLNode
static CTLNode[] CTLAbstractNode.EMPTY_ARRAY
           
 

Methods in edu.toronto.cs.ctl that return CTLNode
static CTLNode CTLFactory.alterChildren(CTLNode psi, CTLNode left, CTLNode right)
          Creates a CTL node that is the same type as the original and has the specified children.
 CTLNode[] CTLUnaryNode.getFairness()
           
 CTLNode[] CTLAbstractNode.getFairness()
          Retrieves the fairness of the CTLNode.
 CTLNode[] CTLNode.getFairness()
          Retrieves the fairness of the CTLNode.
 CTLNode CTLBinaryNode.getLeft()
           
 CTLNode CTLUnaryNode.getLeft()
           
abstract  CTLNode CTLAbstractNode.getLeft()
          Retrieves the left child of the CTLNode.
 CTLNode CTLLeafNode.getLeft()
           
 CTLNode CTLNode.getLeft()
          Retrieves the left child of the CTLNode.
 CTLNode CTLBinaryNode.getRight()
           
 CTLNode CTLUnaryNode.getRight()
           
abstract  CTLNode CTLAbstractNode.getRight()
          Retrieves the right child of the CTLNode.
 CTLNode CTLLeafNode.getRight()
           
 CTLNode CTLNode.getRight()
          Retrieves the right child of the CTLNode.
 

Methods in edu.toronto.cs.ctl with parameters of type CTLNode
 CTLAFNode CTLAbstractNode.af(CTLNode[] fairness)
           
 CTLAFNode CTLNode.af(CTLNode[] fairness)
           
 CTLAGNode CTLAbstractNode.ag(CTLNode[] fairness)
           
 CTLAGNode CTLNode.ag(CTLNode[] fairness)
           
static CTLNode CTLFactory.alterChildren(CTLNode psi, CTLNode left, CTLNode right)
          Creates a CTL node that is the same type as the original and has the specified children.
 CTLAndNode CTLAbstractNode.and(CTLNode psi)
          CTL operation - conjunction.
 CTLAndNode CTLNode.and(CTLNode psi)
          CTL operation - conjunction.
 CTLARNode CTLAbstractNode.ar(CTLNode psi)
           
 CTLARNode CTLNode.ar(CTLNode psi)
          CTL Release node A [this R psi ]
 CTLAUNode CTLAbstractNode.au(CTLNode psi)
          CTL operation - AU ( A[this U psi] ).
 CTLAUNode CTLNode.au(CTLNode psi)
          CTL operation - AU ( A[this U psi] ).
 CTLAUiNode CTLAbstractNode.au(int i, CTLNode psi)
          CTL operation - bounded AU ( A[this Ui psi] ).
 CTLAUiNode CTLNode.au(int i, CTLNode psi)
          CTL operation - bounded AU ( A[this Ui psi] ).
 CTLAWNode CTLAbstractNode.aw(CTLNode psi)
           
 CTLAWNode CTLNode.aw(CTLNode psi)
           
static CTLAFNode CTLFactory.createCTLAFNode(CTLNode right)
           
static CTLAFNode CTLFactory.createCTLAFNode(CTLNode right, CTLNode[] fairness)
           
static CTLAFNode CTLFactory.createCTLAFNode(CTLNode right, CTLNode[] fairness)
           
static CTLAGNode CTLFactory.createCTLAGNode(CTLNode right)
           
static CTLAGNode CTLFactory.createCTLAGNode(CTLNode right, CTLNode[] fairness)
           
static CTLAGNode CTLFactory.createCTLAGNode(CTLNode right, CTLNode[] fairness)
           
static CTLAndNode CTLFactory.createCTLAndNode(CTLNode left, CTLNode right)
           
static CTLARNode CTLFactory.createCTLARNode(CTLNode left, CTLNode right)
           
static CTLAUiNode CTLFactory.createCTLAUiNode(CTLNode left, int i, CTLNode right)
           
static CTLAUiNode CTLFactory.createCTLAUiNode(CTLNode left, int i, CTLNode right, CTLNode[] fairness)
           
static CTLAUiNode CTLFactory.createCTLAUiNode(CTLNode left, int i, CTLNode right, CTLNode[] fairness)
           
static CTLAUNode CTLFactory.createCTLAUNode(CTLNode left, CTLNode right)
           
static CTLAUNode CTLFactory.createCTLAUNode(CTLNode left, CTLNode right, CTLNode[] fairness)
           
static CTLAUNode CTLFactory.createCTLAUNode(CTLNode left, CTLNode right, CTLNode[] fairness)
           
static CTLAWNode CTLFactory.createCTLAWNode(CTLNode left, CTLNode right)
           
static CTLAWNode CTLFactory.createCTLAWNode(CTLNode left, CTLNode right, CTLNode[] fairness)
           
static CTLAWNode CTLFactory.createCTLAWNode(CTLNode left, CTLNode right, CTLNode[] fairness)
           
static CTLAXNode CTLFactory.createCTLAXNode(CTLNode right)
           
static CTLAXNode CTLFactory.createCTLAXNode(CTLNode right, CTLNode[] fairness)
           
static CTLAXNode CTLFactory.createCTLAXNode(CTLNode right, CTLNode[] fairness)
           
static CTLEFNode CTLFactory.createCTLEFNode(CTLNode right)
           
static CTLEFNode CTLFactory.createCTLEFNode(CTLNode right, CTLNode[] fairness)
           
static CTLEFNode CTLFactory.createCTLEFNode(CTLNode right, CTLNode[] fairness)
           
static CTLEGNode CTLFactory.createCTLEGNode(CTLNode right)
           
static CTLEGNode CTLFactory.createCTLEGNode(CTLNode right, CTLNode[] fairness)
           
static CTLEGNode CTLFactory.createCTLEGNode(CTLNode right, CTLNode[] fairness)
           
static CTLEqualsNode CTLFactory.createCTLEqualsNode(CTLNode left, CTLNode right)
           
static CTLERNode CTLFactory.createCTLERNode(CTLNode left, CTLNode right)
           
static CTLEUiNode CTLFactory.createCTLEUiNode(CTLNode left, int i, CTLNode right)
           
static CTLEUiNode CTLFactory.createCTLEUiNode(CTLNode left, int i, CTLNode right, CTLNode[] fairness)
           
static CTLEUiNode CTLFactory.createCTLEUiNode(CTLNode left, int i, CTLNode right, CTLNode[] fairness)
           
static CTLEUNode CTLFactory.createCTLEUNode(CTLNode left, CTLNode right)
           
static CTLEUNode CTLFactory.createCTLEUNode(CTLNode left, CTLNode right, CTLNode[] fairness)
           
static CTLEUNode CTLFactory.createCTLEUNode(CTLNode left, CTLNode right, CTLNode[] fairness)
           
static CTLEWNode CTLFactory.createCTLEWNode(CTLNode left, CTLNode right)
           
static CTLEWNode CTLFactory.createCTLEWNode(CTLNode left, CTLNode right, CTLNode[] fairness)
           
static CTLEWNode CTLFactory.createCTLEWNode(CTLNode left, CTLNode right, CTLNode[] fairness)
           
static CTLEXNode CTLFactory.createCTLEXNode(CTLNode right)
           
static CTLEXNode CTLFactory.createCTLEXNode(CTLNode right, CTLNode[] fairness)
           
static CTLEXNode CTLFactory.createCTLEXNode(CTLNode right, CTLNode[] fairness)
           
static CTLIffNode CTLFactory.createCTLIffNode(CTLNode left, CTLNode right)
           
static CTLImplNode CTLFactory.createCTLImplNode(CTLNode left, CTLNode right)
           
static CTLNegNode CTLFactory.createCTLNegNode(CTLNode right)
           
static CTLOrNode CTLFactory.createCTLOrNode(CTLNode left, CTLNode right)
           
static CTLOverNode CTLFactory.createCTLOverNode(CTLNode left, CTLNode right)
           
static CTLPreEXNode CTLFactory.createCTLPreEXNode(CTLNode right)
           
static CTLUnderNode CTLFactory.createCTLUnderNode(CTLNode left, CTLNode right)
           
 CTLEGNode CTLAbstractNode.eg(CTLNode[] fairness)
           
 CTLEGNode CTLNode.eg(CTLNode[] fairness)
           
 CTLEqualsNode CTLAbstractNode.eq(CTLNode psi)
          CTL operation - equals
 CTLEqualsNode CTLNode.eq(CTLNode psi)
          CTL operation - equals
 CTLERNode CTLAbstractNode.er(CTLNode psi)
           
 CTLERNode CTLNode.er(CTLNode psi)
           
 CTLEUNode CTLAbstractNode.eu(CTLNode psi)
          CTL operation - EU ( E[this U psi] ).
 CTLEUNode CTLNode.eu(CTLNode psi)
          CTL operation - EU ( E[this U psi] ).
 CTLEUiNode CTLAbstractNode.eu(int i, CTLNode psi)
          CTL operation - bounded EU ( E[this Ui psi] ).
 CTLEUiNode CTLNode.eu(int i, CTLNode psi)
          CTL operation - bounded EU ( E[this Ui psi] ).
 CTLEWNode CTLAbstractNode.ew(CTLNode psi)
           
 CTLEWNode CTLNode.ew(CTLNode psi)
           
 CTLIffNode CTLAbstractNode.iff(CTLNode psi)
          CTL operation - equivalence.
 CTLIffNode CTLNode.iff(CTLNode psi)
          CTL operation - equivalence.
 CTLImplNode CTLAbstractNode.impliedBy(CTLNode psi)
          CTL operation - backward implication.
 CTLImplNode CTLNode.impliedBy(CTLNode psi)
          CTL operation - backward implication.
 CTLImplNode CTLAbstractNode.implies(CTLNode psi)
          CTL operation - implication.
 CTLImplNode CTLNode.implies(CTLNode psi)
          CTL operation - implication.
 java.util.Map CTLTemplate.matchCTLNode(CTLNode _node)
           
 boolean CTLTemplate.matchInternal(java.util.Map map, CTLNode _node, CTLNode matchnode)
           
 CTLOrNode CTLAbstractNode.or(CTLNode psi)
          CTL operation - disjunction.
 CTLOrNode CTLNode.or(CTLNode psi)
          CTL operation - disjunction.
 CTLOverNode CTLAbstractNode.over(CTLNode psi)
          CTL operation - over
 CTLOverNode CTLNode.over(CTLNode psi)
          CTL operation - over
static void CTLStyledPrinter.print(CTLNode node, StyledDocumentPrinter styledPrinter)
           
protected  void CTLStyledPrinter.printNode(CTLNode node, java.lang.Object o)
           
 void CTLStyledPrinter.printNode(CTLNode node, StyledDocumentPrinter styledPrinter)
           
static void CTLFactory.removeCTLNode(CTLNode ctl)
           
protected  void CTLBinaryNode.setLeft(CTLNode v)
           
protected  void CTLUnaryNode.setLeft(CTLNode v)
           
protected abstract  void CTLAbstractNode.setLeft(CTLNode l)
          Changes the left child of the CTLNode.
protected  void CTLLeafNode.setLeft(CTLNode v)
           
protected  void CTLBinaryNode.setRight(CTLNode v)
           
protected  void CTLUnaryNode.setRight(CTLNode v)
           
protected abstract  void CTLAbstractNode.setRight(CTLNode r)
          Changes the right child of the CTLNode.
protected  void CTLLeafNode.setRight(CTLNode v)
           
 java.lang.String CTLPrettyPrinter.stringValue(CTLNode node)
           
static java.lang.String CTLPrettyPrinter.toString(CTLNode node)
           
static java.lang.String CTLAbstractNode.toString(CTLNode node, boolean optBrackets)
           
 CTLUnderNode CTLAbstractNode.under(CTLNode psi)
          CTL operation - under
 CTLUnderNode CTLNode.under(CTLNode psi)
          CTL operation - under
 java.lang.Object CTLVisitor.visit(CTLNode n, java.lang.Object stateinfo)
           
 java.lang.Object AbstractCTLVisitor.visit(CTLNode n, java.lang.Object o)
           
 java.lang.Object CTLVisitorDefaulterAncestor.visit(CTLNode n, java.lang.Object stateinfo)
           
 java.lang.Object AbstractCTLVisitor.visitCTLNode(CTLNode n, java.lang.Object o)
           
 java.lang.Object CTLVisitorDefaulterAncestor.visitCTLNode(CTLNode node, java.lang.Object stateinfo)
           
 java.lang.Object CTLVisitor.visitNode(CTLNode node, java.lang.Object stateinfo)
           
 java.lang.Object AbstractCTLVisitor.visitNode(CTLNode node, java.lang.Object o)
           
 java.lang.Object CTLVisitorDefaulterAncestor.visitNode(CTLNode node, java.lang.Object stateinfo)
           
 

Constructors in edu.toronto.cs.ctl with parameters of type CTLNode
CTLAFNode(CTLNode phi)
          Construct an AF CTL node from another node.
CTLAFNode(CTLNode phi, CTLNode[] fairness)
           
CTLAFNode(CTLNode phi, CTLNode[] fairness)
           
CTLAGNode(CTLNode phi)
          Construct an AG CTL node from another node.
CTLAGNode(CTLNode phi, CTLNode[] fairness)
           
CTLAGNode(CTLNode phi, CTLNode[] fairness)
           
CTLAndNode(CTLNode phi, CTLNode psi)
          Construct an And CTL node using two other nodes as its children.
CTLARNode(CTLNode phi, CTLNode psi)
          Construct a universal strong until CTL node using two other nodes as its children.
CTLARNode(CTLNode phi, CTLNode psi, CTLNode[] fairness)
           
CTLARNode(CTLNode phi, CTLNode psi, CTLNode[] fairness)
           
CTLAUiNode(CTLNode phi, int i, CTLNode psi)
          Construct a bounded universal strong until CTL node using two other nodes as its children.
CTLAUiNode(CTLNode phi, int i, CTLNode psi, CTLNode[] fairness)
           
CTLAUiNode(CTLNode phi, int i, CTLNode psi, CTLNode[] fairness)
           
CTLAUNode(CTLNode phi, CTLNode psi)
          Construct a universal strong until CTL node using two other nodes as its children.
CTLAUNode(CTLNode phi, CTLNode psi, CTLNode[] fairness)
           
CTLAUNode(CTLNode phi, CTLNode psi, CTLNode[] fairness)
           
CTLAWNode(CTLNode phi, CTLNode psi)
          Construct a universal strong until CTL node using two other nodes as its children.
CTLAWNode(CTLNode phi, CTLNode psi, CTLNode[] fairness)
           
CTLAWNode(CTLNode phi, CTLNode psi, CTLNode[] fairness)
           
CTLAXNode(CTLNode phi)
          Construct an AX CTL node from another node.
CTLAXNode(CTLNode phi, CTLNode[] fairness)
           
CTLAXNode(CTLNode phi, CTLNode[] fairness)
           
CTLBinaryNode(CTLNode _left, CTLNode _right)
           
CTLBinaryNode(CTLNode _left, CTLNode _right, CTLNode[] fairness)
           
CTLBinaryNode(CTLNode _left, CTLNode _right, CTLNode[] fairness)
           
CTLEFNode(CTLNode phi)
          Construct an EF CTL node from another node.
CTLEFNode(CTLNode phi, CTLNode[] fairness)
           
CTLEFNode(CTLNode phi, CTLNode[] fairness)
           
CTLEGNode(CTLNode phi)
          Construct an EG CTL node from another node.
CTLEGNode(CTLNode phi, CTLNode[] fairness)
           
CTLEGNode(CTLNode phi, CTLNode[] fairness)
           
CTLEqualsNode(CTLNode phi, CTLNode psi)
          Construct an Equals CTL node using two other nodes as its children.
CTLERNode(CTLNode phi, CTLNode psi)
          Construct a universal strong until CTL node using two other nodes as its children.
CTLERNode(CTLNode phi, CTLNode psi, CTLNode[] fairness)
           
CTLERNode(CTLNode phi, CTLNode psi, CTLNode[] fairness)
           
CTLEUiNode(CTLNode phi, int i, CTLNode psi)
          Construct a bounded existential strong until CTL node using two other nodes as its children.
CTLEUiNode(CTLNode phi, int i, CTLNode psi, CTLNode[] fairness)
           
CTLEUiNode(CTLNode phi, int i, CTLNode psi, CTLNode[] fairness)
           
CTLEUNode(CTLNode phi, CTLNode psi)
          Construct an existential strong until CTL node using two other nodes as its children.
CTLEUNode(CTLNode phi, CTLNode psi, CTLNode[] fairness)
           
CTLEUNode(CTLNode phi, CTLNode psi, CTLNode[] fairness)
           
CTLEWNode(CTLNode phi, CTLNode psi)
          Construct a universal strong until CTL node using two other nodes as its children.
CTLEWNode(CTLNode phi, CTLNode psi, CTLNode[] fairness)
           
CTLEWNode(CTLNode phi, CTLNode psi, CTLNode[] fairness)
           
CTLEXNode(CTLNode phi)
          Construct an EX CTL node from another node.
CTLEXNode(CTLNode phi, CTLNode[] fairness)
           
CTLEXNode(CTLNode phi, CTLNode[] fairness)
           
CTLIffNode(CTLNode phi, CTLNode psi)
          Construct an Equivalence CTL node using two other nodes as its children.
CTLImplNode(CTLNode phi, CTLNode psi)
          Construct an Implication CTL node using two other nodes as its children.
CTLNegNode(CTLNode phi)
          Construct a Neg CTL node from another node.
CTLOrNode(CTLNode phi, CTLNode psi)
          Construct an Or CTL node using two other nodes as its children.
CTLOverNode(CTLNode phi, CTLNode psi)
          Construct an Over CTL node using two other nodes as its children.
CTLPreEXNode(CTLNode phi)
          Construct a pre EX CTL node thing from another node.
CTLTemplate(CTLNode _node, java.util.Set _match)
           
CTLUnaryNode(CTLNode _right)
           
CTLUnaryNode(CTLNode _right, CTLNode[] _fairness)
           
CTLUnaryNode(CTLNode _right, CTLNode[] _fairness)
           
CTLUnderNode(CTLNode phi, CTLNode psi)
          Construct an Under CTL node using two other nodes as its children.
 

Uses of CTLNode in edu.toronto.cs.ctl.antlr
 

Methods in edu.toronto.cs.ctl.antlr that return CTLNode
 CTLNode CTLTreeBuilder.afExpression(antlr.collections.AST _t)
           
 CTLNode CTLTreeBuilder.agExpression(antlr.collections.AST _t)
           
 CTLNode CTLTreeBuilder.andExpression(antlr.collections.AST _t)
           
 CTLNode CTLTreeBuilder.axExpression(antlr.collections.AST _t)
           
 CTLNode CTLTreeBuilder.comparissonExpression(antlr.collections.AST _t)
           
 CTLNode CTLTreeBuilder.ctlTree(antlr.collections.AST _t)
           
 CTLNode CTLTreeBuilder.efExpression(antlr.collections.AST _t)
           
 CTLNode CTLTreeBuilder.egExpression(antlr.collections.AST _t)
           
 CTLNode CTLTreeBuilder.eqExpression(antlr.collections.AST _t)
           
 CTLNode CTLTreeBuilder.exExpression(antlr.collections.AST _t)
           
 CTLNode CTLTreeBuilder.forallUntil(antlr.collections.AST _t)
           
 CTLNode CTLTreeBuilder.forsomeUntil(antlr.collections.AST _t)
           
 CTLNode CTLTreeBuilder.geqExpression(antlr.collections.AST _t)
           
 CTLNode CTLTreeBuilder.impliesExpression(antlr.collections.AST _t)
           
 CTLNode CTLTreeBuilder.leqExpression(antlr.collections.AST _t)
           
 CTLNode CTLTreeBuilder.modalExpression(antlr.collections.AST _t)
           
 CTLNode CTLTreeBuilder.neqExpression(antlr.collections.AST _t)
           
 CTLNode CTLTreeBuilder.notExpression(antlr.collections.AST _t)
           
 CTLNode CTLTreeBuilder.orExpression(antlr.collections.AST _t)
           
static CTLNode CTLNodeParser.parse(java.io.Reader in)
           
static CTLNode CTLNodeParser.parse(java.io.Reader in, CTLNode[] fairness)
           
static CTLNode CTLNodeParser.parse(java.lang.String ctlStr)
           
static CTLNode CTLNodeParser.parse(java.lang.String ctlStr, CTLNode[] fairness)
           
 CTLNode CTLTreeBuilder.placeholder(antlr.collections.AST _t)
           
static CTLNode CTLNodeParser.safeParse(java.lang.String ctlStr)
          Parses a String into CTL without exceptions.
static CTLNode CTLNodeParser.safeParse(java.lang.String ctlStr, CTLNode[] fairness)
           
 CTLNode CTLTreeBuilder.untillReleaseExpression(antlr.collections.AST _t)
           
 

Methods in edu.toronto.cs.ctl.antlr with parameters of type CTLNode
static CTLNode CTLNodeParser.parse(java.io.Reader in, CTLNode[] fairness)
           
static CTLNode CTLNodeParser.parse(java.lang.String ctlStr, CTLNode[] fairness)
           
static CTLNode CTLNodeParser.safeParse(java.lang.String ctlStr, CTLNode[] fairness)
           
 

Constructors in edu.toronto.cs.ctl.antlr with parameters of type CTLNode
CTLTreeBuilder(CTLNode[] _fairness)
           
 

Uses of CTLNode in edu.toronto.cs.gclang.parser
 

Methods in edu.toronto.cs.gclang.parser that return CTLNode
 CTLNode VariableTable.handleUnknownVariable(java.lang.String name)
           
abstract  CTLNode VariableTable.Variable.toCTL(AlgebraValue[] state)
           
 CTLNode VariableTable.EnumeratedVariable.toCTL(AlgebraValue[] state)
           
 CTLNode VariableTable.StateVariable.toCTL(AlgebraValue[] state)
           
 

Uses of CTLNode in edu.toronto.cs.gui
 

Methods in edu.toronto.cs.gui that return CTLNode
 CTLNode[] OptionsPanel.getAllFairness()
          Get all fairness conditions regardless of whether they are turned on or not.
 CTLNode[] OptionsPanel.getFairness()
          Get fairness.
 CTLNode XChekGUI.parseCTL(java.lang.String ctlStr)
           
 CTLNode XChekGUI.prepareCTL(java.lang.String ctlStr)
           
 CTLNode XChekGUI.rewriteCTL(CTLNode ctl)
           
 

Methods in edu.toronto.cs.gui with parameters of type CTLNode
 CTLNode XChekGUI.rewriteCTL(CTLNode ctl)
           
 

Uses of CTLNode in edu.toronto.cs.modelchecker
 

Methods in edu.toronto.cs.modelchecker that return CTLNode
 CTLNode XKripkeStructure.rewrite(CTLNode ctlNode)
           
 CTLNode CTLReWriter.rewrite(CTLNode ctl)
           
 CTLNode NormalFormRewriter.rewrite(CTLNode node)
           
 CTLNode CloningRewriter.rewrite(CTLNode ctl)
           
 CTLNode SyntaxChecker.rewrite(CTLNode node)
           
 CTLNode[] StatePresenter.toCTL(AlgebraValue[] state)
           
 CTLNode[][] StatePresenter.toCTL(AlgebraValue[][] states)
           
 CTLNode[] StatePresenter.toCTL(MvSet cube)
           
 

Methods in edu.toronto.cs.modelchecker with parameters of type CTLNode
 MvSet MvSetModelChecker.__checkCTL(CTLNode ctl, MvSet init)
           
 MvSet MvSetModelChecker.checkCTL(CTLNode v)
           
 MvSet MvSetModelChecker.checkCTL(CTLNode ctl, MvSet state)
           
 CTLNode XKripkeStructure.rewrite(CTLNode ctlNode)
           
 CTLNode CTLReWriter.rewrite(CTLNode ctl)
           
 CTLNode NormalFormRewriter.rewrite(CTLNode node)
           
 CTLNode CloningRewriter.rewrite(CTLNode ctl)
           
 CTLNode SyntaxChecker.rewrite(CTLNode node)
           
 

Uses of CTLNode in edu.toronto.cs.proof
 

Methods in edu.toronto.cs.proof that return CTLNode
 CTLNode ProofStep.getConsequent()
           
 

Methods in edu.toronto.cs.proof with parameters of type CTLNode
 java.util.BitSet GenericDisjStrategy.choosePaths(AlgebraValue[] vals, CTLNode[] props)
           
 java.util.BitSet Simple2ValDisjStrategy.choosePaths(AlgebraValue[] vals, CTLNode[] props)
           
 java.util.BitSet ProofStrategy.choosePaths(AlgebraValue[] vals, CTLNode[] props)
           
static java.util.Iterator ProofStrategyCatalog.iterator(CTLNode type)
           
static ProofStep ProofStepFactory.makeProofStep(AlgebraValue _v, MvSet _state, CTLNode _consequent)
           
 void Proof.searchProof(CTLNode ctl)
           
 

Constructors in edu.toronto.cs.proof with parameters of type CTLNode
ConjProofStep(AlgebraValue _v, MvSet _state, java.lang.String _stateName, CTLNode _consequent)
           
DisjProofStep(AlgebraValue _v, MvSet _state, java.lang.String stateName, CTLNode _consequent, DisjProofStrategy _strategy)
           
EGProofStep(AlgebraValue _v, MvSet _state, java.lang.String _stateName, CTLNode _consequent)
           
EUiProofStep(AlgebraValue _v, MvSet _state, java.lang.String _stateName, CTLNode _consequent, int _bound)
           
EUProofStep(AlgebraValue _v, MvSet _state, java.lang.String _stateName, CTLNode _consequent)
           
EXProofStep(AlgebraValue _v, MvSet _state, java.lang.String _stateName, CTLNode _consequent)
           
NegProofStep(AlgebraValue _v, MvSet _state, java.lang.String _stateName, CTLNode _consequent)
           
ProofStep(AlgebraValue _v, MvSet _state, java.lang.String _stateName, CTLNode _consequent)
           
PropProofStep(AlgebraValue _v, MvSet _state, java.lang.String _stateName, CTLNode _consequent)
           
 

Uses of CTLNode in edu.toronto.cs.proof2
 

Methods in edu.toronto.cs.proof2 that return CTLNode
 CTLNode Formula.getConsequent()
           
 

Methods in edu.toronto.cs.proof2 with parameters of type CTLNode
 java.lang.Object DepthVisitor.binaryNontemporalVisit(CTLNode node, java.lang.Object stateinfo)
           
 java.lang.Object DepthVisitor.binaryTemporalVisit(CTLNode node, java.lang.Object stateinfo)
           
 int DepthVisitor.ctlDepth(CTLNode node)
           
static Formula Formula.duplicate(Formula f, CTLNode ctl, AlgebraValue val, MvSet state)
           
 void CTLProver.BaseEXProofRule.getSuccessorMap(MvSet state, java.lang.String name, CTLNode conseq)
           
 java.lang.Object DepthVisitor.unaryNontemporalVisit(CTLNode node, java.lang.Object stateinfo)
           
 java.lang.Object DepthVisitor.unaryTemporalVisit(CTLNode node, java.lang.Object stateinfo)
           
 

Constructors in edu.toronto.cs.proof2 with parameters of type CTLNode
AboveFormula(CTLNode _ctl, AlgebraValue _val, MvSet _state)
           
BelowFormula(CTLNode _ctl, AlgebraValue _val, MvSet _state)
           
ComparisonFormula(CTLNode _ctl, AlgebraValue _val, MvSet _state)
           
EqualFormula(CTLNode _ctl, AlgebraValue _val, MvSet _state)
           
Formula(CTLNode _ctl, AlgebraValue _val, MvSet _state)
           
 

Uses of CTLNode in edu.toronto.cs.simulator
 

Methods in edu.toronto.cs.simulator that return CTLNode
 CTLNode[] XCSimulator.getBreakCond()
          Gets the break condition(s).
 CTLNode XCSimulator.getElseCond()
          Gets the alternative condition for the current step (in case the first one fails).
 CTLNode XCSimulator.getStepCond()
          Gets the condition for the current step.
 CTLNode TraceTreeBrowser.parseCTL(java.lang.String ctlStr)
          Parses a String into CTL without exceptions.
 CTLNode[] XCTraceTree.stateToArray(XCStateInfo info)
          Eventually this will allow to merge siblings into one multi-state.
 

Methods in edu.toronto.cs.simulator with parameters of type CTLNode
 void XCTraceTree.expand(XCTraceState state, CTLNode condition)
          Given some initial state will add the successor states (as one multistate) satisfying the condition.
 void XCTraceTree.expandOne(XCTraceState state, CTLNode condition)
          Given some initial state will pick one of the successor states satisfying the condition and add it as a child.
 XCTraceState XCTraceTree.split(XCTraceState state, CTLNode condition)
          Given a (multi-)state will attempt to split a single state off of it, modifying the tree accordingly (add 2 siblings in place of the old state).
 

Uses of CTLNode in edu.toronto.cs.smv
 

Methods in edu.toronto.cs.smv that return CTLNode
 CTLNode VariableTable.handleUnknownVariable(java.lang.String name)
           
abstract  CTLNode VariableTable.Variable.toCTL(AlgebraValue[] state)
           
 CTLNode VariableTable.EnumeratedVariable.toCTL(AlgebraValue[] state)
           
 CTLNode VariableTable.StateVariable.toCTL(AlgebraValue[] state)
           
 CTLNode[] SMVModule.SMVStatePresenter.toCTL(AlgebraValue[] state)
           
 CTLNode SMVModule.Variable.toCTL(AlgebraValue[] state)
           
 CTLNode SMVModule.AlgebraVariable.toCTL(AlgebraValue[] state)
           
 CTLNode SMVModule.IntVariable.toCTL(AlgebraValue[] state)
           
 CTLNode[][] SMVModule.SMVStatePresenter.toCTL(AlgebraValue[][] states)
           
 CTLNode[] SMVModule.SMVStatePresenter.toCTL(MvSet cube)
           
 

Uses of CTLNode in edu.toronto.cs.tlq
 

Methods in edu.toronto.cs.tlq that return CTLNode
 CTLNode PlaceholderReWriter.getOneSolution(int bits, StatePresenter presenter, boolean negated)
           
 CTLNode MvSetPlaceholderReWriter.getOneSolution(MvSet v, StatePresenter presenter, boolean negated)
           
 CTLNode PlaceholderReWriter.getSolution(int bits, StatePresenter presenter)
           
 CTLNode MvSetPlaceholderReWriter.getSolution(MvSetCrossProductAlgebra.CrossProductValue v, StatePresenter presenter)
           
 CTLNode[] PlaceholderReWriter.getSolutions(AlgebraValue v, StatePresenter presenter)
           
 CTLNode[] MvSetPlaceholderReWriter.getSolutions(AlgebraValue v, StatePresenter presenter)