Uses of Interface
laser.alphabet.LabelInterface

Packages that use LabelInterface
laser.alphabet Contains classes for creating and manipulating alphabets.
 
laser.alphabet.event Provides classes and interfaces for event notification when a change occurs within an alphabet.
 
laser.alphabet.labelpattern Contains classes for creating and manipulating label patterns.
 
laser.alphabet.test   
laser.regularlanguage.fsa Contains classes for creating and manipulating finite state automata (FSAs). 
laser.regularlanguage.fsa.test   
laser.regularlanguage.fsa.util Utility classes commonly useful for FSAs.
 
laser.regularlanguage.fsa.util.test   
laser.regularlanguage.regularexpression Contains classes and interfaces for creating and manipulating regular expressions (REs). 
laser.regularlanguage.regularexpression.parser Provides classes for lexing and parsing (regular) expressions.
 
laser.regularlanguage.regularexpression.reparser Provides classes for lexing and parsing REs. 
laser.regularlanguage.regularexpression.test   
laser.regularlanguage.regularexpression.util Utility classes commonly useful for REs.
 
laser.regularlanguage.regularexpression.util.test   
laser.regularlanguage.util Utility classes commonly useful for regular languages (RLs). 
laser.regularlanguage.util.test   
 

Uses of LabelInterface in laser.alphabet
 

Classes in laser.alphabet with type parameters of type LabelInterface
 interface AlphabetFactoryInterface<L extends LabelInterface>
          This interface is implemented by all types of Alphabet factories.
 interface AlphabetInterface<L extends LabelInterface>
          This interface is implemented by all types of Alphabets.
 interface LabelInterface<L extends LabelInterface>
          This interface is implemented by all types of Labels.
 

Classes in laser.alphabet that implement LabelInterface
 class AbstractLabel<L extends AbstractLabel>
          This is an abstract class which all types of Labels extend.
 class IndexedLabel
          IndexedLabels are Labels that represent integers from 0 to (N - 1), where N is specified by the Alphabet the IndexedLabels are associated with.
 class StringLabel
          StringLabels are Labels that represent Strings.
 

Uses of LabelInterface in laser.alphabet.event
 

Classes in laser.alphabet.event with type parameters of type LabelInterface
 class AlphabetChangeEvent<L extends LabelInterface>
          The AlphabetChangeEvent class represents when the given alphabet has been changed.
 interface AlphabetChangeListener<L extends LabelInterface>
          The AlphabetChangeListener interface allows an object to observe an alphabet and be notified whenever a change occurs.
 class AlphabetChangeManager<L extends LabelInterface>
          The AlphabetChangeManager class provides the ability for an alphabet to be observed by registered listeners and notifies any registered listeners whenever a change occurs.
 

Uses of LabelInterface in laser.alphabet.labelpattern
 

Classes in laser.alphabet.labelpattern with type parameters of type LabelInterface
 class AbstractClassSetLabelPattern<L extends LabelInterface>
          An abstract class providing common functionality for both ClassSetLabelPatterns and NotClassSetLabelPatterns.
 class AbstractLabelPatternFactory<L extends LabelInterface>
          A basic implementation of LabelPatternFactory functionality.
 class AllLabelPattern<L extends LabelInterface>
          This class represents an "all" LabelPattern.
 class ClassSetLabelPattern<L extends LabelInterface>
          This class represents a "class set" LabelPattern.
 interface ClassSetLabelPatternInterface<L extends LabelInterface>
          An interface implemented by "class set" LabelPatterns.
 interface LabelPatternFactoryInterface<L extends LabelInterface>
          An interface implemented by all types of LabelPatternFactories.
 interface LabelPatternInterface<L extends LabelInterface>
          An interface implemented by all types of LabelPatterns.
 class NotClassSetLabelPattern<L extends LabelInterface>
          This class represents a "not class set" LabelPattern.
 interface NotClassSetLabelPatternInterface<L extends LabelInterface>
          An interface implemented by "not class set" LabelPatterns.
 

Methods in laser.alphabet.labelpattern that return LabelInterface
 LabelInterface StringLabelPatternParser.label()
           
 LabelInterface LabelPatternParser.label()
           
 LabelInterface IndexedLabelPatternParser.label()
           
 

Uses of LabelInterface in laser.alphabet.test
 

Classes in laser.alphabet.test with type parameters of type LabelInterface
 class EventAlphabetTest.MockAlphabetChangeListener<L extends LabelInterface>
          Implements an AlphabetChangeListener
 

Uses of LabelInterface in laser.regularlanguage.fsa
 

Classes in laser.regularlanguage.fsa with type parameters of type LabelInterface
 class AbstractFSA<L extends LabelInterface>
          An abstract FSA class that provides common functionality for FSAs of type FSAInterface.
 class AbstractFSAFactory<L extends LabelInterface>
          An abstract class extended by all factories that create finite state automata (FSAs) of type AbstractFSA.
 class AbstractFSATransition<L extends LabelInterface>
          An abstract class that represents a transition in an FSA of type FSAInterface.
 class AbstractFSATransitionTable<L extends LabelInterface>
          A helper class for RunnableFSAs that allows computation to be performed on them.
 class AbstractMutableFSA<L extends LabelInterface>
          An abstract class representing FSAs that are mutable.
 class AbstractRunnableFSA<L extends LabelInterface>
          An abstract class representing FSAs that are runnable.
 class DeadStateEliminator<L extends LabelInterface>
          The DeadStateEliminator class eliminates all dead states.
 interface DFAInterface<L extends LabelInterface>
          A DFA is a deterministic finite state automaton.
 class DFATransitionTable<L extends LabelInterface>
          A helper class for RunnableDFAs that allows computation to be performed on them.
 class FSADotWriter<L extends LabelInterface>
          The FSADotWriter class outputs the given FSA in dot format to the specified output.
 class FSAEpsilonTransition<L extends LabelInterface>
          This class represents epsilon (ε) transitions in FSAs of type AbstractFSA.
 interface FSAEpsilonTransitionInterface<L extends LabelInterface>
          Classes implementing this interface represent epsilon (ε) transitions in FSAs of type FSAInterface.
 interface FSAFactoryInterface<L extends LabelInterface>
          This interface is implemented by all factories that create finite state automata (FSAs) of type FSAInterface.
 interface FSAInterface<L extends LabelInterface>
          An FSA is a finite state automaton.
 class FSALabelPatternTransition<L extends LabelInterface>
          This class represents transitions on a LabelPattern in FSAs of type AbstractFSA.
 interface FSALabelPatternTransitionInterface<L extends LabelInterface>
          Classes implementing this interface represent transitions on a LabelPattern in FSAs of type MutableFSAInterface.
 class FSALabelTransition<L extends LabelInterface>
          This class represents transitions on a Label in FSAs of type AbstractFSA.
 interface FSALabelTransitionInterface<L extends LabelInterface>
          Classes implementing this interface represent transitions on a Label in FSAs of type FSAInterface.
 class FSAState<L extends LabelInterface>
          An FSAState represents a state in an FSA of type FSAInterface.
 interface FSAStateInterface<L extends LabelInterface>
          Classes implementing this interface represent states in FSAs of type FSAInterface.
 interface FSATransitionInterface<L extends LabelInterface>
          Classes implementing this interface represent transitions in FSAs of type FSAInterface.
 class FSATransitionTable<L extends LabelInterface>
          A helper class for RunnableFSAs that allows computation to be performed on them.
 class MutableDFA<L extends LabelInterface>
          This class represents DFAs that are mutable.
 interface MutableDFAInterface<L extends LabelInterface>
          This class represents mutable FSAs that have been explicitly specified as being deterministic.
 class MutableFSA<L extends LabelInterface>
          This class represents FSAs that are mutable.
 interface MutableFSAInterface<L extends LabelInterface>
          This class represents FSAs that are mutable: i.e. their structure can be changed but no computation can be performed on them.
 class RunnableDFA<L extends LabelInterface>
          This class represents DFAs that are runnable.
 interface RunnableDFAInterface<L extends LabelInterface>
          This class represents runnable FSAs that have been explicitly specified as being deterministic.
 class RunnableFSA<L extends LabelInterface>
          This class represents FSAs that are runnable.
 interface RunnableFSAInterface<L extends LabelInterface>
          This class represents FSAs that are runnable: i.e. computation can be performed on them but their structure can not be changed.
 class SourceStateIterator<L extends LabelInterface>
          The SourceStateIterator class provides a way to convert the given Set of FSATransitionInterfaces into an Iterator over the FSAStateInterfaces that are the sources of those transitions.
 class TargetStateIterator<L extends LabelInterface>
          The TargetStateIterator class provides a way to convert the given Set of FSATransitionInterfaces into an Iterator over the FSAStateInterfaces that are the targets of those transitions.
 class TotalFSATransformer<L extends LabelInterface>
          The TotalFSATransformer class transforms the given FSA into a total FSA.
 class UnreachableStateEliminator<L extends LabelInterface>
          The UnreachableStateEliminator class elimates all states contained within the given FSA that are not reachable from the start state.
 

Uses of LabelInterface in laser.regularlanguage.fsa.test
 

Classes in laser.regularlanguage.fsa.test with type parameters of type LabelInterface
 class AbstractMutableFSAFactory<L extends LabelInterface>
           
 class AbstractRunnableFSAFactory<L extends LabelInterface>
           
 class FSARelatedTests<L extends LabelInterface>
           
 class FSAStateTests<L extends LabelInterface>
           
 class FSATests<L extends LabelInterface>
           
 class MutableFSAStateTests<L extends LabelInterface>
           
 class MutableFSATests<L extends LabelInterface>
           
 class RunnableFSAStateTests<L extends LabelInterface>
           
 class RunnableFSATests<L extends LabelInterface>
           
 

Uses of LabelInterface in laser.regularlanguage.fsa.util
 

Classes in laser.regularlanguage.fsa.util with type parameters of type LabelInterface
 class AbstractComposer<L extends LabelInterface>
          The AbstractComposer class computes the composite FSA from the given FSAs.
 class AbstractFSAs<L extends LabelInterface>
          The AbstractFSAs class contains various methods for manipulating finite state automata (FSAs) such as regular operations, set operations, and others.
 class CompositeState<L extends LabelInterface>
          A composite state is used when computing the composition of two FSAs and represents a state that has one state from the first FSA and one state from the second FSA.
 class FSAPair<L extends LabelInterface>
          The FSAPair class represents an ordered pair of FSAs.
 class FSAs<L extends LabelInterface>
          The FSAs class contains various methods for manipulating finite state automata (FSAs) such as regular operations, set operations, and others.
 class Inflater<L extends LabelInterface>
          The Inflater class inflates the given FSA with regards to the specified Alphabet.
 class IntersectionComposer<L extends LabelInterface>
          The IntersectionComposer class computes the intersection FSA from the given FSAs.
 class Minimizer<L extends LabelInterface>
          Minimizes the number of states of the given DFA, including deleting dead and unreachable states.
 class NFAtoDFAConverter<L extends LabelInterface>
          Converts an NFA (Nondetermanistic Finite State Automaton) to a DFA (Determanistic Finite State Automaton).
 class ProductComposer<L extends LabelInterface>
          The ProductComposer class computes the (cross) product FSA from the given FSAs.
 class UnionComposer<L extends LabelInterface>
          The UnionComposer class computes the union FSA from the given FSAs.
 

Uses of LabelInterface in laser.regularlanguage.fsa.util.test
 

Classes in laser.regularlanguage.fsa.util.test with type parameters of type LabelInterface
 class FSAsTests<L extends LabelInterface>
          The FSAsTests class tests the FSAs class' methods.
 

Uses of LabelInterface in laser.regularlanguage.regularexpression
 

Classes in laser.regularlanguage.regularexpression with type parameters of type LabelInterface
 class AbstractREVisitor<L extends LabelInterface>
          The AbstractREVisitor class implements the visitor pattern.
 class BinaryTreeNode<L extends LabelInterface>
          The BinaryTreeNode class represents a TreeNode with two children.
 class ChoiceNode<L extends LabelInterface>
          ChoiceNode represents a choice between two regular expressions, meaning either the first or second expression occurs.
 class ClassSetNode<L extends LabelInterface>
          ClassSetNode is a leaf node in the Regular Expression Parse Tree representing a set of labels, meaning a choice between any label in the set.
 class ConcatenationNode<L extends LabelInterface>
          ConcatenationNode represents the Concatenation of two regular expressions, meaning the first expression occurs then the second expression occurs.
 class DefaultREFactory<L extends LabelInterface>
          The DefaultREFactory class allows the user to create new REs.
 class DotNode<L extends LabelInterface>
          DotNode is a leaf node in the Regular Expression representing a wildcard, meaning a choice among any label.
 class EmptyNode<L extends LabelInterface>
          EmptyNode represents the empty language.
 class EpsilonNode<L extends LabelInterface>
          LabelNode is a leaf node in the Regular Expression representing an event.
 class ExponentNode<L extends LabelInterface>
          ExponentNode represents an Exponent (^) in the regular expression.
 class KleenePlusNode<L extends LabelInterface>
          KleenePlusNode represents a Kleene Plus (+) in the regular expression, meaning the expression occurs one or more times.
 class KleeneStarNode<L extends LabelInterface>
          KleeneStarNode represents a Kleene Star (*) in the regular expression, meaning the expression occurs zero or more times.
 class LabelNode<L extends LabelInterface>
          LabelNode is a leaf node in the Regular Expression representing an event.
 class NotClassSetNode<L extends LabelInterface>
          NotClassSetNode is a node in the Regular Expression representing the negation of a set of labels, meaning a choice between any label not in the set.
 class OptionNode<L extends LabelInterface>
          OptionNode represents an Option (?) in the regular expression parse tree, meaning the expression can occur 0 or 1 times.
 class RE<L extends LabelInterface>
          An RE represents a regular expresssion (RE).
 interface REFactory<L extends LabelInterface>
          The REFactory interface allows the user to create new REs.
 interface REVisitor<L extends LabelInterface>
          The REVisitor class implements the visitor pattern.
 class TreeNode<L extends LabelInterface>
          TreeNode is an abstract class that all classes used in building a Regular Expression inherit from.
 class UnaryTreeNode<L extends LabelInterface>
          The UnaryTreeNode class represents a TreeNode with a single child.
 

Uses of LabelInterface in laser.regularlanguage.regularexpression.parser
 

Methods in laser.regularlanguage.regularexpression.parser that return LabelInterface
 LabelInterface RegularExpressionParser.label()
          A label in a regular expression.
 

Methods in laser.regularlanguage.regularexpression.parser that return types with arguments of type LabelInterface
 java.util.Set<LabelInterface> RegularExpressionParser.labelList()
          labelList := label (COMMA label)* A labelList is a comma separated list of labels.
 

Uses of LabelInterface in laser.regularlanguage.regularexpression.reparser
 

Methods in laser.regularlanguage.regularexpression.reparser that return LabelInterface
 LabelInterface REParser.label()
           
 

Methods in laser.regularlanguage.regularexpression.reparser that return types with arguments of type LabelInterface
 java.util.Set<LabelInterface> REParser.labelList()
           
 

Uses of LabelInterface in laser.regularlanguage.regularexpression.test
 

Classes in laser.regularlanguage.regularexpression.test with type parameters of type LabelInterface
 class RETests<L extends LabelInterface>
           
 

Uses of LabelInterface in laser.regularlanguage.regularexpression.util
 

Classes in laser.regularlanguage.regularexpression.util with type parameters of type LabelInterface
 class AbstractREConverter<L extends LabelInterface>
          The AbstractREConverter class allows the given old RE to be converted to the corresponding new RE.
 class AbstractRegularExpressions<L extends LabelInterface>
          The AbstractRegularExpressions class contains various methods for manipulating regular expressions (REs).
 class ExtendedREToREConverter<L extends LabelInterface>
          The ExtendedREToREConverter class converts from an extended RE to a (basic) RE.
 class RegularExpressions<L extends LabelInterface>
          The RegularExpressions class contains various methods for manipulating regular expressions (REs).
 class REPair<L extends LabelInterface>
          The REPair class represents an ordered pair of REs.
 class REPrinter<L extends LabelInterface>
          The REPrinter class prints out the given RE to the specified Writer.
 class REReader<L extends LabelInterface>
          The REReader class reads in the RE from the specified input.
 class RESimplifier<L extends LabelInterface>
          The RESimplifier class simplifies the given RE by applying identities to remove terms.
 class REWriter<L extends LabelInterface>
          The REWriter class writes out the RE to the specified output.
 class StringREtoREConverter<L extends LabelInterface>
          The StringREtoREConverter class converts from an input RE that uses StringLabels to the corresponding output RE that uses the specified Labels.
 

Uses of LabelInterface in laser.regularlanguage.regularexpression.util.test
 

Classes in laser.regularlanguage.regularexpression.util.test with type parameters of type LabelInterface
 class RegularExpressionsTests<L extends LabelInterface>
           
 

Uses of LabelInterface in laser.regularlanguage.util
 

Classes in laser.regularlanguage.util with type parameters of type LabelInterface
 class AbstractRegularLanguages<L extends LabelInterface>
          The AbstractRegularLanguages class contains various methods for manipulating regular languages (RLs) represented as REs and FSAs.
 class AbstractREtoDFAVisitor<L extends LabelInterface>
          The AbstractREtoDFAVisitor class allows an RE with a right end MarkerNode to be visited.
 class DefaultRLFactory<L extends LabelInterface>
          The DefaultRLFactory class helps users to convert between FSAs and REs.
 class FSAtoREConverter<L extends LabelInterface>
          The FSAtoREConverter class converts from the given FSA to the corresponding RE.
 class GNFA<L extends LabelInterface>
          The GNFA class represents a generalized nondeterministic finite automaton (GNFA).
 class MarkerNode<L extends LabelInterface>
          MarkerNode is the special end of regular expression node that is needed in the RE to DFA algorithm.
 class RegularLanguages<L extends LabelInterface>
          The RegularLanguages class contains various methods for manipulating regular languages (RLs) represented as REs and FSAs.
 class REtoDFABuilder<L extends LabelInterface>
          The REtoDFABuilder class builds a Deterministic Finite State Automaton (DFA) from the given (basic) Regular Expresion (RE).
 class REtoDFAConverter<L extends LabelInterface>
          The REtoDFAConverter class converts from the given RE to its corresponding DFA.
 class REtoDFAInfoPrinter<L extends LabelInterface>
          The REtoDFAInfoPrinter class for each TreeNode within the RE parse tree prints out its associated REToDFAInfo Object.
 class REtoDFAParser<L extends LabelInterface>
          The REtoDFAParser class converts from the input RE to its corresponding DFA.
 class REtoFSAConverter<L extends LabelInterface>
          The REtoFSAParser class converts from the given RE to the corresponding FSA.
 class REtoFSAParser<L extends LabelInterface>
          The REtoFSAParser class reads in the given RE from the specified input and converts the RE to the corresponding FSA.
 class REtoNFAConverter<L extends LabelInterface>
          The REtoNFAConverter class converts from a basic Regular Expression (RE) to a Non-Deterministic Finite State Automaton (NFA).
 interface RLFactory<L extends LabelInterface>
          The RLFactory interface provides helper methods for converting between FSAs and REs.
 

Uses of LabelInterface in laser.regularlanguage.util.test
 

Classes in laser.regularlanguage.util.test with type parameters of type LabelInterface
 class RegularLanguagesTests<L extends LabelInterface>
          The RegularLanguagesTests class tests the RegularLanguages class.