Packages

  • package root

    Dregex is a Scala/JVM library that implements a regular expression engine using deterministic finite automata (DFA).

    Dregex is a Scala/JVM library that implements a regular expression engine using deterministic finite automata (DFA). The range of features supported is an middle ground between Perl-style (slow) engines and DFA-based ones. Yet it retains the linear matching time offered by the latter.

    Definition Classes
    root
  • package dregex

    Main package for Dregex implementation.

    Main package for Dregex implementation. User-facing classes reside directly in the top-level package. The rest of the sub-packages contain implementation classes.

    Definition Classes
    root
  • CompiledRegex
  • InvalidRegexException
  • ParsedRegex
  • Regex
  • SynteticRegex
  • Universe

object Regex

Linear Supertypes
AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Regex
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##: Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  5. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native() @HotSpotIntrinsicCandidate()
  6. def compile(regexes: Seq[String], flags: Int = 0): Seq[CompiledRegex]

    Compiles a set of regular expressions in the same Universe, with the given flags.

    Compiles a set of regular expressions in the same Universe, with the given flags. Scala version.

    flags

    match flags, a bit mask that may include java.util.regex.Pattern.LITERAL, and java.util.regex.Pattern.COMMENTS.

  7. def compile(regexes: List[String]): List[CompiledRegex]

    Compiles a set of regular expressions in the same Universe.

    Compiles a set of regular expressions in the same Universe. Java version.

  8. def compile(regexes: List[String], flags: Int): List[CompiledRegex]

    Compiles a set of regular expressions in the same Universe, with the given flags.

    Compiles a set of regular expressions in the same Universe, with the given flags. Java version.

    flags

    match flags, a bit mask that may include java.util.regex.Pattern.LITERAL, and java.util.regex.Pattern.COMMENTS.

  9. def compile(regex: String): CompiledRegex

    Compiles a set of regular expressions in the same Universe.

  10. def compile(regex: String, flags: Int): CompiledRegex

    Compile a regex from a string, using it's own Universe, with the given flags.

    Compile a regex from a string, using it's own Universe, with the given flags.

    flags

    match flags, a bit mask that may include java.util.regex.Pattern.LITERAL, and java.util.regex.Pattern.COMMENTS.

  11. def compileParsed(parsedRegex: ParsedRegex, universe: Universe): CompiledRegex

    Compile a regex parsed using one of the parse methods.

    Compile a regex parsed using one of the parse methods.

    In general, this method is not necessary; a call to one of the compile methods is simpler and more direct. However, there are cases in which the intermediate ParsedRegexs are needed. Most notably, when caching CompiledRegex instances (which are in general more expensive to create).

  12. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  13. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  14. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  15. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  16. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  17. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  18. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  19. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  20. def nullRegex(u: Universe): Regex

    Create a regular expression that does not match anything.

    Create a regular expression that does not match anything. Note that that is different from matching the empty string. Despite the theoretical equivalence of automata and regular expressions, in practice there is no regular expression that does not match anything.

  21. def parse(regexes: List[String], flags: Int): List[ParsedRegex]

    Parse a set of regular expressions from a string, with the given flags.

    Parse a set of regular expressions from a string, with the given flags. Java version.

    In general, this method is not necessary; a call to one of the compile methods is simpler and more direct. However, there are cases in which the intermediate ParsedRegexs are needed. Most notably, when caching CompiledRegex instances (which are in general more expensive to create).

    flags

    match flags, a bit mask that may include java.util.regex.Pattern.LITERAL, and java.util.regex.Pattern.COMMENTS.

  22. def parse(regexes: Seq[String], flags: Int = 0): Seq[ParsedRegex]

    Parse a set of regular expressions from a string, with the given flags.

    Parse a set of regular expressions from a string, with the given flags. Scala version.

    In general, this method is not necessary; a call to one of the compile methods is simpler and more direct. However, there are cases in which the intermediate ParsedRegexs are needed. Most notably, when caching CompiledRegex instances (which are in general more expensive to create).

    flags

    match flags, a bit mask that may include java.util.regex.Pattern.LITERAL, and java.util.regex.Pattern.COMMENTS.

  23. def parse(regex: String, flags: Int): ParsedRegex

    Parse a regular expression from a string, with the given flags.

    Parse a regular expression from a string, with the given flags.

    In general, this method is not necessary; a call to one of the compile methods is simpler and more direct. However, there are cases in which the intermediate ParsedRegexs are needed. Most notably, when caching CompiledRegex instances (which are in general more expensive to create).

    flags

    match flags, a bit mask that may include java.util.regex.Pattern.LITERAL, and java.util.regex.Pattern.COMMENTS.

  24. def parse(regex: String): ParsedRegex

    Parse a regular expression from a string.

    Parse a regular expression from a string.

    In general, this method is not necessary; a call to one of the compile methods is simpler and more direct. However, there are cases in which the intermediate ParsedRegexs are needed. Most notably, when caching CompiledRegex instances (which are in general more expensive to create).

  25. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  26. def toString(): String
    Definition Classes
    AnyRef → Any
  27. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  28. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()
  29. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])

Deprecated Value Members

  1. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable]) @Deprecated
    Deprecated

Inherited from AnyRef

Inherited from Any

Ungrouped