Generex (Generex 1.0.2 API)

java.lang.Object
- com.mifmif.common.regex.Generex

All Implemented Interfaces:

Iterable
```
public class Generex
extends Object
implements Iterable
```
A Java utility class that help generating string values that match a given regular expression.It generate all values that are matched by the Regex, a random value, or you can generate only a specific string based on it's lexicographical order .

Author:

y.mifrah

Field Summary

Fields
Modifier and Type	Field and Description
`private dk.brics.automaton.Automaton`	`automaton`
`private boolean`	`isTransactionNodeBuilt`
`private int`	`matchedStringCounter`
`private List<String>`	`matchedStrings`
`private static Map<String,String>`	`PREDEFINED_CHARACTER_CLASSES` The predefined character classes supported by `Generex`.
`private int`	`preparedTransactionNode`
`private Random`	`random`
`private dk.brics.automaton.RegExp`	`regExp`
`private Node`	`rootNode`

Constructor Summary

Constructors
Constructor and Description
`Generex(dk.brics.automaton.Automaton automaton)`
`Generex(dk.brics.automaton.Automaton automaton, Random random)`
`Generex(String regex)`
`Generex(String regex, Random random)`

Method Summary

Methods
Modifier and Type	Method and Description
`private void`	`buildRootNode()` Prepare the rootNode and it's child nodes so that we can get matchedString by index
`private String`	`buildStringFromNode(Node node, int indexOrder)`
`private static dk.brics.automaton.RegExp`	`createRegExp(String regex)` Creates a `RegExp` instance from the given regular expression.
`private void`	`generate(String strMatch, dk.brics.automaton.State state, int limit)`
`List<String>`	`getAllMatchedStrings()` Generate all Strings that matches the given Regex.
`String`	`getFirstMatch()`
`String`	`getMatchedString(int indexOrder)`
`List<String>`	`getMatchedStrings(int limit)` Generate subList with a size of `limit` of Strings that matches the given Regex. the Strings are ordered in lexicographical order.
`boolean`	`isInfinite()` Tells whether or not the given pattern (or `Automaton`) is infinite, that is, generates an infinite number of strings.
`static boolean`	`isValidPattern(String regex)` Tells whether or not the given regular expression is a valid pattern (for `Generex`).
`Iterator`	`iterator()`
`long`	`matchedStringsSize()`
`private String`	`prepareRandom(String strMatch, dk.brics.automaton.State state, int minLength, int maxLength)`
`private List<Node>`	`prepareTransactionNodes(dk.brics.automaton.State state)` Build list of nodes that present possible transactions from the `state`.
`String`	`random()` Generate and return a random String that match the pattern used in this Generex.
`String`	`random(int minLength)` Generate and return a random String that match the pattern used in this Generex, and the string has a length >= `minLength`
`String`	`random(int minLength, int maxLength)` Generate and return a random String that match the pattern used in this Generex, and the string has a length >= `minLength` and <= `maxLength`
`private static String`	`requote(String regex)` Requote a regular expression by escaping some parts of it from generation without need to escape each special character one by one.
`void`	`setSeed(long seed)` initialize the random instance used with a seed value to generate a pseudo random suite of strings based on the passed seed and matches the used regular expression instance

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - PREDEFINED_CHARACTER_CLASSES
```
private static final Map<String,String> PREDEFINED_CHARACTER_CLASSES
```
    The predefined character classes supported by Generex.
    An immutable map containing as keys the character classes and values the equivalent regular expression syntax.
    
    See Also:
    createRegExp(String)
  - regExp
```
private dk.brics.automaton.RegExp regExp
```
  - automaton
```
private dk.brics.automaton.Automaton automaton
```
  - matchedStrings
```
private List<String> matchedStrings
```
  - rootNode
```
private Node rootNode
```
  - isTransactionNodeBuilt
```
private boolean isTransactionNodeBuilt
```
  - matchedStringCounter
```
private int matchedStringCounter
```
  - preparedTransactionNode
```
private int preparedTransactionNode
```
  - random
```
private Random random
```
- Constructor Detail
  - Generex
```
public Generex(String regex)
```
  - Generex
```
public Generex(dk.brics.automaton.Automaton automaton)
```
  - Generex
```
public Generex(String regex,
       Random random)
```
  - Generex
```
public Generex(dk.brics.automaton.Automaton automaton,
       Random random)
```
- Method Detail
  - createRegExp
```
private static dk.brics.automaton.RegExp createRegExp(String regex)
```
    Creates a RegExp instance from the given regular expression.
    Predefined character classes are replaced with equivalent regular expression syntax prior creating the instance.
    
    Parameters:
    regex - the regular expression used to build the RegExp instance
    
    Returns:
    a RegExp instance for the given regular expression
    
    Throws:
    
    NullPointerException - if the given regular expression is null
    
    IllegalArgumentException - if an error occurred while parsing the given regular expression
    
    StackOverflowError - if the regular expression has to many transitions
    See Also:
    PREDEFINED_CHARACTER_CLASSES, isValidPattern(String)
  - setSeed
```
public void setSeed(long seed)
```
    initialize the random instance used with a seed value to generate a pseudo random suite of strings based on the passed seed and matches the used regular expression instance
    
    Parameters:
    seed -
  - getMatchedString
```
public String getMatchedString(int indexOrder)
```
    Parameters:
    indexOrder - ( 1<= indexOrder <=n)
    
    Returns:
    The matched string by the given pattern in the given it's order in the sorted list of matched String.
    indexOrder between 1 and n where n is the number of matched String.
    If indexOrder >= n , return an empty string. if there is an infinite number of String that matches the given Regex, the method throws StackOverflowError
  - buildStringFromNode
```
private String buildStringFromNode(Node node,
                         int indexOrder)
```
  - isInfinite
```
public boolean isInfinite()
```
    Tells whether or not the given pattern (or Automaton) is infinite, that is, generates an infinite number of strings.
    For example, the pattern "a+" generates an infinite number of strings whether "a{5}" does not.
    
    Returns:
    true if the pattern (or Automaton) generates an infinite number of strings, false otherwise
  - getFirstMatch
```
public String getFirstMatch()
```
    Returns:
    first string in lexicographical order that is matched by the given pattern.
  - matchedStringsSize
```
public long matchedStringsSize()
```
    Returns:
    the number of strings that are matched by the given pattern.
    
    Throws:
    
    StackOverflowError - if the given pattern generates a large, possibly infinite, number of strings.
  - buildRootNode
```
private void buildRootNode()
```
    Prepare the rootNode and it's child nodes so that we can get matchedString by index
  - generate
```
private void generate(String strMatch,
            dk.brics.automaton.State state,
            int limit)
```
  - prepareTransactionNodes
```
private List<Node> prepareTransactionNodes(dk.brics.automaton.State state)
```
    Build list of nodes that present possible transactions from the state.
    
    Parameters:
    state -
    
    Returns:
  - getAllMatchedStrings
```
public List<String> getAllMatchedStrings()
```
    Generate all Strings that matches the given Regex.
    
    Returns:
  - getMatchedStrings
```
public List<String> getMatchedStrings(int limit)
```
    Generate subList with a size of limit of Strings that matches the given Regex. the Strings are ordered in lexicographical order.
    
    Parameters:
    limit -
    
    Returns:
  - random
```
public String random()
```
    Generate and return a random String that match the pattern used in this Generex.
    
    Returns:
  - random
```
public String random(int minLength)
```
    Generate and return a random String that match the pattern used in this Generex, and the string has a length >= minLength
    
    Parameters:
    minLength -
    
    Returns:
  - random
```
public String random(int minLength,
            int maxLength)
```
    Generate and return a random String that match the pattern used in this Generex, and the string has a length >= minLength and <= maxLength
    
    Parameters:
    minLength -
    maxLength -
    
    Returns:
  - prepareRandom
```
private String prepareRandom(String strMatch,
                   dk.brics.automaton.State state,
                   int minLength,
                   int maxLength)
```
  - iterator
```
public Iterator iterator()
```
    Specified by:
    
    iterator in interface Iterable
  - isValidPattern
```
public static boolean isValidPattern(String regex)
```
    Tells whether or not the given regular expression is a valid pattern (for Generex).
    
    Parameters:
    regex - the regular expression that will be validated
    
    Returns:
    true if the regular expression is valid, false otherwise
    
    Throws:
    
    NullPointerException - if the given regular expression is null
  - requote
```
private static String requote(String regex)
```
    Requote a regular expression by escaping some parts of it from generation without need to escape each special character one by one.
    this is done by setting the part to be interpreted as normal characters (thus, quote all meta-characters) between \Q and \E , ex :
    minion_\d{3}\Q@gru.evil\E
    will be transformed to :
    minion_\d{3}\@gru\.evil
    
    Parameters:
    regex -
    
    Returns:

Class Generex

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

PREDEFINED_CHARACTER_CLASSES

regExp

automaton

matchedStrings

rootNode

isTransactionNodeBuilt

matchedStringCounter

preparedTransactionNode

random

Constructor Detail

Generex

Generex

Generex

Generex

Method Detail

createRegExp

setSeed

getMatchedString

buildStringFromNode

isInfinite

getFirstMatch

matchedStringsSize

buildRootNode

generate

prepareTransactionNodes

getAllMatchedStrings

getMatchedStrings

random

random

random

prepareRandom

iterator

isValidPattern

requote