com.mifmif.common.regex

Class Generex

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(String regex)

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)

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: