Returns an automaton with projected alphabet. The new automaton accepts all strings that are projections of strings accepted by the given automaton on

Compare two lists of objects for reference-equality.

Replace the last added outgoing transition's target state with the given state.

Constructs automaton that accepts 0x20, 0x9, 0xa, and 0xd in place of each 0x20 transition in the given automaton. @param a automaton @return automato

See {@link BasicOperations#run(Automaton, String)}.

Sets alphabet table for optimal run performance.

Sets deterministic flag for this automaton. This method should (only) be used if automata are constructed manually. @param deterministic true if the a

Copy <code>current</code> into an internal buffer.

Returns an automaton that accepts the shuffle (interleaving) of the languages of the given automata. As a side-effect, both automata are determinized,

Returns a string that is an interleaving of strings that are accepted by <code>ca</code> but not by <code>a</code>. If no such string exists, null is

Returns an automaton that accepts the single chars that occur in strings that are accepted by the given automaton. Never modifies the input automaton.

Writes this <code>MatchOnlyRunAutomaton</code> to the given stream. @param stream output stream for serialized automaton @exception IOException if inp

Returns true if the language of <code>a1</code> is a subset of the language of <code>a2</code>. As a side-effect, <code>a2</code> is determinized if n

For normal operation, simply return the transitioned to state. If the transition is to an accepted state and an override value is provided, then retur

Returns an automaton that accepts the trimmed language of the given automaton. The resulting automaton is constructed as follows: 1) Whenever a <code>

Constructs a new automaton that accepts the empty language. Using this constructor, automata can be constructed manually from {@link State} and {@link

Constructs a new automaton provider that recognizes all names from {@link Datatypes#get(String)}.

Constructs a new state. Initially, the new state is a reject state.

Constructs a new singleton interval transition. @param c transition character @param to destination state

Clones this transition. @return clone with same character interval and destination state

Compares by (min, reverse max, to) or (to, min, reverse max).

See {@link SpecialOperations#compress(Automaton, String, char)}.

Returns the offset after the last character matched. @return The offset after the last character matched. @throws IllegalStateException if there has

Checks for equality. @param obj object to compare with @return true if <code>obj</code> represents the same pair of states as this pair

Checks for equality. @param obj object to compare with @return true if <code>obj</code> is a transition with same character interval and desti

Returns true if the language of this automaton is equal to the language of the given automaton. Implemented using <code>hashCode</code> and <code>subs

Two states are equal if: <ul> <li>they have an identical number of outgoing transitions, labeled with the same labels</li> <li>corresponding outgoing

Checks whether a given automaton is available. @param name automaton name @return true if the automaton is available

Returns the state of the allow mutate flag. If this flag is set, then all automata operations may modify automata given as input; otherwise, operation

Returns array of character class interval start points. The array should not be modified by the caller.

See {@link SpecialOperations#getCommonPrefix(Automaton)}.

See {@link SpecialOperations#getFiniteStrings(Automaton)}.

Returns first component of this pair. @return first state

Returns set of automaton identifiers that occur in this regular expression.

Returns extra information associated with this automaton. @return extra information @see #setInfo(Object)

Returns initial state.

Returns maximum of this transition interval.

Returns minimum of this transition interval.

Returns second component of this pair. @return second state

See {@link BasicOperations#getShortestExample(Automaton, boolean)}.

Returns the singleton string for this automaton. An automaton that accepts exactly one string <i>may</i> be represented in singleton mode. In that cas

Returns number of states in automaton.

Returns an array of outgoing transitions from this state. The returned array must not be changed.

See {@link SpecialOperations#getStrings(Automaton, int)}.

Returns an array of outgoing transition labels. The array is sorted in lexicographic order and indexes correspond to states returned from {@link #getS

Returns the subsequence of the input found by the previous match. @return The subsequence of the input found by the previous match. @throws IllegalSt

Returns the number of capturing groups in the underlying automaton. <br> Note that because the automaton does not support capturing groups this method

Returns hash code. @return hash code

Returns hash code. The hash code is based on the character interval (not the destination state). @return hash code

Compute the hash code of the <i>current</i> status of this state.

See {@link java.lang.Object#hashCode()}.

See {@link SpecialOperations#hexCases(Automaton)}.

See {@link SpecialOperations#homomorph(Automaton, char[], char[])}.

Returns acceptance status for given state.

See {@link BasicOperations#isEmptyString(Automaton)}.

Is this state a final state in the automaton?

See {@link SpecialOperations#isFinite(Automaton)}.

See {@link BasicOperations#isTotal(Automaton)}.

Retrieves a serialized <code>RunAutomaton</code> located by a URL. @param url URL of serialized automaton @exception IOException if input/output relat

Invoke during compilation to pre-build automata. Automata are stored in the directory specified by the system property <code>dk.brics.automaton.dataty

See {@link BasicAutomata#makeAnyChar()}.

See {@link BasicAutomata#makeAnyString()}.

See {@link BasicAutomata#makeDecimalValue(String)}.

See {@link BasicAutomata#makeEmpty()}.

See {@link BasicAutomata#makeEmptyString()}.

See {@link BasicAutomata#makeFractionDigits(int)}.

See {@link BasicAutomata#makeIntegerValue(String)}.

See {@link BasicAutomata#makeInterval(int, int, int)}.

See {@link BasicAutomata#makeMinInteger(String)}.

See {@link BasicAutomata#makeStringMatcher(String)}.

See {@link BasicAutomata#makeStringUnion(CharSequence...)}.

See {@link BasicAutomata#makeTotalDigits(int)}.

See {@link SpecialOperations#overlap(Automaton, Automaton)}.