Docjar: A Java Source and Docuemnt Enginecom.*    java.*    javax.*    org.*    all    new    plug-in

Quick Search    Search Deep

Uses of Class

Uses of AbstractRegularExpression in

Subclasses of AbstractRegularExpression in
 class AlternateExpression
          A regular expression that mimics the "x|y" RegExp syntax.
 class CommentExpression
          Parse comment strings.
 class DefaultParser
          Default implementation of the parser interface [pending : create interface !].
 class EnclosingExpression
          An expression that can encompass a sub-expression it encloses with markers, e.g.
 class GNURegExpression
          An expression specified by a gnu.regexp.RE regular expression.
 class InstanciationExpression
          An expression that can instanciate a new Element by cloning the given graphic element when it finds a given litteral tag, then add it to the current PicGroup in the pool.
 class LaTeXParser
          LaTeX (including epic/eepic and pstricks macros) parser This class consists essentially of LaTeX grammar rules (subexpression included in the "root" sequence expression) and a method "parse()" which kicks off the parsing process.
 class LiteralExpression
          An expression specified by a String to be exactly matched at the current cursor position.
 class NotParsableExpression
          Any string (but w/o line-feeds !)
 class NumericalExpression
          An expression containing only digits, possibly preceded by whitespaces ; a post-delimiters can be specified, as well as the number's type (int or double) and its sign
 class OptionalExpression
          an expression that represents a pattern repeating at most once
 class PicPointExpression
          An expression for 2D-Point parsing e.g.
 class RepeatExpression
          an expression that represents a pattern repeating a given number of times
 class RootExpression
          This is the super-class for head-expressions that contain grammar rule for a given format.
 class SequenceExpression
          An expression that represents a sequence of expressions to be matched exactly in the same order they're being added to the sequence.
 class StatementExpression
          An expression for "statement"-parsing, i.e.
 class TerminalExpression
          This expression works a bit like a "CR-greedy" expression : it scans each line until it can successfully parse the reg-exp given in the constructor, POSSIBLY preceded by wild-chars (as given in the construror).
 class WhiteSpaces
          Multiple white spaces (w/o line-feeds)
 class WhiteSpacesOrEOL
          multiple white spaces and/or '\n'
 class WildCharExpression
          an Expression that represents a single occurence of a wild-char (ANY_CHAR or one of the predefinite fields in java.lang.Character)
 class WordExpression
          A string, - either composed of letters only, or letters and digits (see java.lang.Character.isLetter() for details) only, - or ended by the specified end-delimiter (in which case it may contain other chars than letters)

Fields in declared as AbstractRegularExpression
private  AbstractRegularExpression TerminalExpression.expr
private  AbstractRegularExpression TerminalExpression.wildExpr
private  AbstractRegularExpression StatementExpression.exp1
private  AbstractRegularExpression StatementExpression.exp2
private  AbstractRegularExpression StatementExpression.exp3
private  AbstractRegularExpression RepeatExpression.expr
private  AbstractRegularExpression PicPointExpression.exp1
private  AbstractRegularExpression PicPointExpression.exp2
private  AbstractRegularExpression PicPointExpression.exp3
private  AbstractRegularExpression PicPointExpression.exp4
private  AbstractRegularExpression ParserException.expr
          the expression that raised this exception
private  AbstractRegularExpression ParserEvent.source
private  AbstractRegularExpression OptionalExpression.expr
private  AbstractRegularExpression EnclosingExpression.child

Methods in that return AbstractRegularExpression
 AbstractRegularExpression ParserEvent.getSource()

Methods in with parameters of type AbstractRegularExpression
 void SequenceExpression.add(AbstractRegularExpression expr)
          add the given expression to the sequence
 void RepeatExpression.setPattern(AbstractRegularExpression expr)
          set the base-pattern to the given expression
 void EnclosingExpression.setChild(AbstractRegularExpression child)
          Change the child of this expression to the given expression
 void AlternateExpression.add(AbstractRegularExpression expr)
          Add a new child to this AlternateExpression.

Constructors in with parameters of type AbstractRegularExpression
TerminalExpression(AbstractRegularExpression expr)
          Calls TerminalExpression(expr, WHITESPACES) => "expr" can only be preceded by whitespaces
TerminalExpression(AbstractRegularExpression expr, int type)
SequenceExpression(AbstractRegularExpression expr)
          constructs a sequence with the given expression as the first sub-expression and which doesn't throw IncompleteSequenceException.
SequenceExpression(AbstractRegularExpression expr, boolean throwIncompleteSequenceException)
          constructs a sequence with the given expression as the first sub-expression.
SequenceExpression(AbstractRegularExpression expr1, AbstractRegularExpression expr2)
          constructs a sequence with the given expression as the first and second sub-expression and which doesn't throw Exception
SequenceExpression(AbstractRegularExpression expr1, AbstractRegularExpression expr2, boolean throwIncompleteSequenceException)
          constructs a sequence with the given expression as the first and second sub-expression
SequenceExpression(AbstractRegularExpression expr1, AbstractRegularExpression expr2, AbstractRegularExpression expr3, boolean throwIncompleteSequenceException)
          constructs a sequence with three sub-expressions
RepeatExpression(AbstractRegularExpression expr, int repeat, int mode)
ParserException(java.lang.String errorCode, Context context, AbstractRegularExpression expr)
          create a new ParserException, raised by the given Expression
ParserException.IncompleteSequence(Context c, AbstractRegularExpression expr)
ParserException.NumberFormat(Context c, AbstractRegularExpression expr)
ParserException.NumberSign(Context c, AbstractRegularExpression expr)
ParserException.EndGroupMismatch(Context c, AbstractRegularExpression expr)
ParserException.BeginGroupMismatch(Context c, AbstractRegularExpression expr)
ParserException.BlockMismatch(Context c, AbstractRegularExpression expr)
ParserException.NotFoundInFile(Context c, AbstractRegularExpression expr)
ParserException.SyntaxError(Context c, AbstractRegularExpression expr)
ParserException.EOF(Context c, AbstractRegularExpression expr)
ParserEvent(AbstractRegularExpression source, Context context, boolean parsingSuccessful, java.lang.Object value)
OptionalExpression(AbstractRegularExpression expr)
          the expression to be matched (yet optionally)
EnclosingExpression(java.lang.String openingDelimiter, AbstractRegularExpression child, java.lang.String closingDelimiter, boolean noLineFeed)
EnclosingExpression(java.lang.String openingDelimiter, AbstractRegularExpression child, java.lang.String closingDelimiter)
AlternateExpression(AbstractRegularExpression expr)
          Creates a new AlternateExpression with the given expr as first element
AlternateExpression(AbstractRegularExpression expr1, AbstractRegularExpression expr2)
          Creates a new AlternateExpression with the given expr as first and second element
AlternateExpression(AbstractRegularExpression expr1, AbstractRegularExpression expr2, AbstractRegularExpression expr3)
          Creates a new AlternateExpression with the given expr as first, second and third element