class Parser extends AnyRef
- Note
This class constructor is private, instances must be created using the companion weaponregex.parser.Parser object
,The parsing rules methods inside this class is created based on the defined grammar
- Alphabetic
- By Inheritance
- Parser
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##: Int
- Definition Classes
- AnyRef → Any
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- def Indexed[_, T](p: => P[T])(implicit arg0: P[Any]): P[(Location, T)]
A higher order parser that add weaponregex.model.Location index information of the parse of the given parser
A higher order parser that add weaponregex.model.Location index information of the parse of the given parser
- p
the parser to be indexed
- returns
A tuple of the weaponregex.model.Location of the parse, and the return of the given parser
p
- def RE[_](implicit arg0: P[Any]): P[RegexTree]
The top-level parsing rule which can parse either
or
orsimpleRE
The top-level parsing rule which can parse either
or
orsimpleRE
- returns
any supported regex
Example: - def anyDot[_](implicit arg0: P[Any]): P[AnyDot]
Parse an any(dot) (
.
) predefined character classParse an any(dot) (
.
) predefined character class- returns
weaponregex.model.regextree.AnyDot tree node
"."
Example: - final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def basicRE[_](implicit arg0: P[Any]): P[RegexTree]
Intermediate parsing rule which can parse either
quantifier
orelementaryRE
Intermediate parsing rule which can parse either
quantifier
orelementaryRE
- returns
weaponregex.model.regextree.RegexTree (sub)tree
- def bol[_](implicit arg0: P[Any]): P[BOL]
Parse a beginning of line character (
^
)
- def boundary[_](implicit arg0: P[Any]): P[RegexTree]
Intermediate parsing rule for boundary tokens which can parse either
bol
,eol
orboundaryMetaChar
Intermediate parsing rule for boundary tokens which can parse either
bol
,eol
orboundaryMetaChar
- returns
weaponregex.model.regextree.RegexTree (sub)tree
- def boundaryMetaChar[_](implicit arg0: P[Any]): P[Boundary]
Parse a boundary meta-character character (
\b
,\B
,\A
,\G
,\z
,\Z
)Parse a boundary meta-character character (
\b
,\B
,\A
,\G
,\z
,\Z
)- returns
weaponregex.model.regextree.BOL tree node
"\z"
Example: - def capturing[_](implicit arg0: P[Any]): P[RegexTree]
Intermediate parsing rule for capturing-related tokens which can parse either
group
orspecialConstruct
Intermediate parsing rule for capturing-related tokens which can parse either
group
orspecialConstruct
- returns
weaponregex.model.regextree.RegexTree (sub)tree
- def charClass[_](implicit arg0: P[Any]): P[CharacterClass]
Parse a character class
- def charHex[_](implicit arg0: P[Any]): P[MetaChar]
Parse a character with hexadecimal value
\xhh
Parse a character with hexadecimal value
\xhh
- returns
weaponregex.model.regextree.MetaChar tree node
"\x01"
Example: - def charHexBrace[_](implicit arg0: P[Any]): P[MetaChar]
Parse a character with hexadecimal value with braces
\x{h...h}
(Character.MIN_CODE_POINT <= 0xh...h <= Character.MAX_CODE_POINT)Parse a character with hexadecimal value with braces
\x{h...h}
(Character.MIN_CODE_POINT <= 0xh...h <= Character.MAX_CODE_POINT)- returns
weaponregex.model.regextree.MetaChar tree node
"\x{0123}"
Example: - def charLiteral[_](implicit arg0: P[Any]): P[Character]
Parse a single literal character that is not a regex special character
Parse a single literal character that is not a regex special character
- returns
weaponregex.model.regextree.Character tree node
"a"
Example: - def charOct[_](implicit arg0: P[Any]): P[MetaChar]
Parse a character with octal value
\0n
,\0nn
,\0mn
(0 <= m <= 3, 0 <= n <= 7)Parse a character with octal value
\0n
,\0nn
,\0mn
(0 <= m <= 3, 0 <= n <= 7)- returns
weaponregex.model.regextree.MetaChar tree node
"\0123"
Example: - def charUnicode[_](implicit arg0: P[Any]): P[MetaChar]
Parse a unicode character
\ uhhhh
Parse a unicode character
\ uhhhh
- returns
weaponregex.model.regextree.MetaChar tree node
"\ u0020"
Example: - def character[_](implicit arg0: P[Any]): P[RegexTree]
Intermediate parsing rule for character-related tokens which can parse either
metaCharacter
orcharLiteral
Intermediate parsing rule for character-related tokens which can parse either
metaCharacter
orcharLiteral
- returns
weaponregex.model.regextree.RegexTree (sub)tree
- def classItem[_](implicit arg0: P[Any]): P[RegexTree]
Intermediate parsing rule for character class item tokens which can parse either
range
,charClass
,preDefinedCharClass
orcharLiteral
Intermediate parsing rule for character class item tokens which can parse either
range
,charClass
,preDefinedCharClass
orcharLiteral
- returns
weaponregex.model.regextree.RegexTree (sub)tree
- Note
Nested character class is a Scala/Java-only regex syntax
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native() @HotSpotIntrinsicCandidate()
- def concat[_](implicit arg0: P[Any]): P[Concat]
Parse a concatenation of
basicRE
s - def elementaryRE[_](implicit arg0: P[Any]): P[RegexTree]
Intermediate parsing rule which can parse either
capturing
,anyDot
,preDefinedCharClass
,boundary
,charClass
,reference
,character
orquote
Intermediate parsing rule which can parse either
capturing
,anyDot
,preDefinedCharClass
,boundary
,charClass
,reference
,character
orquote
- returns
weaponregex.model.regextree.RegexTree (sub)tree
- def eol[_](implicit arg0: P[Any]): P[EOL]
Parse a beginning of line character (
$
) - final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- def escapeChar[_](implicit arg0: P[Any]): P[MetaChar]
Parse an escape meta-character (
\\
,\t
,\n
,\r
,\f
)Parse an escape meta-character (
\\
,\t
,\n
,\r
,\f
)- returns
weaponregex.model.regextree.MetaChar tree node
"\n"
- Note
\a
,\c
, and\e
is not supported.\a
and\e
are valid but interpreted differently in Scala/Java and JavaScript.
Example: - def flagNCGroup[_](implicit arg0: P[Any]): P[FlagNCGroup]
Parse a non-capturing group with flags
Parse a non-capturing group with flags
"(?id-mu:abc)"
- Note
This is a Scala/Java-only regex syntax
Example: - def flagToggle[_](fs: String)(implicit arg0: P[Any]): P[FlagToggle]
Parse a flag toggle (
idmsuxU-idmsuxU
)Parse a flag toggle (
idmsuxU-idmsuxU
)- returns
weaponregex.model.regextree.FlagToggle tree node
"idmsuxU-idmsuxU"
- Note
This is a Scala/Java-only regex syntax
Example: - def flagToggleGroup[_](implicit arg0: P[Any]): P[FlagToggleGroup]
Parse a flag toggle group
Parse a flag toggle group
"(?id-mu)"
- Note
This is a Scala/Java-only regex syntax
Example: - def flags[_](fs: String)(implicit arg0: P[Any]): P[Flags]
Parse flag literal characters given a string contains all allowed flags
Parse flag literal characters given a string contains all allowed flags
- fs
The string contains all allowed flags
- returns
weaponregex.model.regextree.Flags tree node
- Annotations
- @SuppressWarnings()
"idmsuxU"
- Note
This is a Scala/Java-only regex syntax
Example: - final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- def group[_](implicit arg0: P[Any]): P[Group]
Parse a capturing group
- def groupName[_](implicit arg0: P[Any]): P[String]
Parse a group name that starts with a letter and followed by zero or more alphanumeric characters
Parse a group name that starts with a letter and followed by zero or more alphanumeric characters
- returns
the parsed name string
"name1"
Example: - def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- def incGroup[_](implicit arg0: P[Any]): P[INCGroup]
Parse an independent non-capturing group
Parse an independent non-capturing group
"(?>abc)"
- Note
This is a Scala/Java-only regex syntax
Example: - final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def lookaround[_](implicit arg0: P[Any]): P[Lookaround]
Parse a positive or negative lookahead or lookbehind
Parse a positive or negative lookahead or lookbehind
"(?=abc)"
(positive lookahead)
Example: - def metaCharacter[_](implicit arg0: P[Any]): P[RegexTree]
Intermediate parsing rule for meta-character tokens which can parse either
charOct
,charHex
,charUnicode
,charHexBrace
orescapeChar
Intermediate parsing rule for meta-character tokens which can parse either
charOct
,charHex
,charUnicode
,charHexBrace
orescapeChar
- returns
weaponregex.model.regextree.RegexTree (sub)tree
- def nameReference[_](implicit arg0: P[Any]): P[NameReference]
Parse a reference to a named capturing group
Parse a reference to a named capturing group
"\k<name1>"
Example: - def namedGroup[_](implicit arg0: P[Any]): P[NamedGroup]
Parse a named-capturing group
Parse a named-capturing group
- returns
weaponregex.model.regextree.NamedGroup tree node
"(?<name1>hello)"
Example: - final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def nonCapturingGroup[_](implicit arg0: P[Any]): P[Group]
Parse a non-capturing group
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- def numReference[_](implicit arg0: P[Any]): P[NumberReference]
Parse a numbered reference to a capture group
Parse a numbered reference to a capture group
"\13"
Example: - def number[_](implicit arg0: P[Any]): P[Int]
Parse an integer with any number of digits between 0 and 9
Parse an integer with any number of digits between 0 and 9
- returns
the parsed integer
"123"
Example: - def or[_](implicit arg0: P[Any]): P[Or]
Parse an 'or' (
|
) ofsimpleRE
- def parse: Option[RegexTree]
Parse the given regex pattern
Parse the given regex pattern
- returns
An
Option
al parsed weaponregex.model.regextree.RegexTree
- val pattern: String
- def preDefinedCharClass[_](implicit arg0: P[Any]): P[PredefinedCharClass]
Parse a predefined character class (
\d
,\D
,\s
,\S
,\w
,\W
)Parse a predefined character class (
\d
,\D
,\s
,\S
,\w
,\W
)- returns
"\d"
Example: - def quantifier[_](implicit arg0: P[Any]): P[RegexTree]
Intermediate parsing rule for quantifier tokens which can parse either
quantifierShort
orquantifierLong
Intermediate parsing rule for quantifier tokens which can parse either
quantifierShort
orquantifierLong
- returns
weaponregex.model.regextree.RegexTree (sub)tree
- def quantifierLong[_](implicit arg0: P[Any]): P[Quantifier]
Parse a (full) quantifier (
{n}
,{n,}
,{n,m}
)Parse a (full) quantifier (
{n}
,{n,}
,{n,m}
)- returns
weaponregex.model.regextree.Quantifier tree node
"a{1}"
Example: - def quantifierShort[_](implicit arg0: P[Any]): P[RegexTree]
Parse a shorthand notation for quantifier (
?
,*
,+
)Parse a shorthand notation for quantifier (
?
,*
,+
)- returns
weaponregex.model.regextree.RegexTree (sub)tree
"a*"
Example: - def quantifierType[_, T](p: => P[T])(implicit arg0: P[Any]): P[(T, QuantifierType)]
A higher order parser that add weaponregex.model.regextree.QuantifierType information of the parse of the given (quantifier) parser
A higher order parser that add weaponregex.model.regextree.QuantifierType information of the parse of the given (quantifier) parser
- p
the quantifier parser
- returns
A tuple of the return of the given (quantifier) parser
p
, and its weaponregex.model.regextree.QuantifierType
- def quote[_](implicit arg0: P[Any]): P[RegexTree]
Intermediate parsing rule for quoting tokens which can parse either
quoteLong
orquoteChar
Intermediate parsing rule for quoting tokens which can parse either
quoteLong
orquoteChar
- returns
weaponregex.model.regextree.RegexTree (sub)tree
- def quoteChar[_](implicit arg0: P[Any]): P[QuoteChar]
Parse a quoted character (any character)
- def quoteLong[_](implicit arg0: P[Any]): P[Quote]
Parse a 'long' quote, using
\Q
and\E
Parse a 'long' quote, using
\Q
and\E
- returns
weaponregex.model.regextree.Quote tree node
"\Qquoted\E"
Example: - def range[_](implicit arg0: P[Any]): P[Range]
Parse a character range inside a character class
Parse a character range inside a character class
- returns
weaponregex.model.regextree.Range tree node
"a-z"
Example: - def reference[_](implicit arg0: P[Any]): P[RegexTree]
Intermediate parsing rule for reference tokens which can parse either
nameReference
ornumReference
Intermediate parsing rule for reference tokens which can parse either
nameReference
ornumReference
- returns
weaponregex.model.regextree.RegexTree (sub)tree
- def simpleRE[_](implicit arg0: P[Any]): P[RegexTree]
Intermediate parsing rule which can parse either
concat
orbasicRE
Intermediate parsing rule which can parse either
concat
orbasicRE
- returns
weaponregex.model.regextree.RegexTree (sub)tree
- def specialConstruct[_](implicit arg0: P[Any]): P[RegexTree]
Intermediate parsing rule for special construct tokens which can parse either
namedGroup
,nonCapturingGroup
,flagToggleGroup
,flagNCGroup
,lookaround
orincGroup
Intermediate parsing rule for special construct tokens which can parse either
namedGroup
,nonCapturingGroup
,flagToggleGroup
,flagNCGroup
,lookaround
orincGroup
- returns
weaponregex.model.regextree.RegexTree (sub)tree
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def toString(): String
- Definition Classes
- AnyRef → Any
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
Deprecated Value Members
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable]) @Deprecated
- Deprecated