Add another character sequence to this automaton. The sequence must be lexicographically larger or equal compared to any previous sequences added to t

See {@link BasicAutomata#makeCharRange(char, char)}.

Returns pre-built automaton. Automata are loaded as resources from the class loader of the <code>Datatypes</code> class. (Typically, the pre-built aut

Returns the set of states that are reachable from the initial state. @return set of {@link State} objects

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

See {@link BasicAutomata#makeChar(char)}.

See {@link MinimizationOperations#minimize(Automaton)}.

Adds an outgoing transition. @param t transition

Returns string describing this state. Normally invoked via {@link Automaton#toString()}.

Returns a clone of this automaton unless <code>allow_mutation</code> is set, expands if singleton.

Constructs new <code>Automaton</code> from this <code>RegExp</code>. Same as <code>toAutomaton(null)</code> (empty automaton map).

Removes transitions to dead states and calls {@link #reduce()} and {@link #clearHashCode()}. (A state is "dead" if no accept state is reachable from i

Returns a clone of this automaton.

Returns true if the given automaton accepts no strings.

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

Must be invoked when the stored hash code may no longer be valid.

Returns a new (deterministic) automaton with the empty language.

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

Returns the set of reachable accept states. @return set of {@link State} objects

Returns a sorted array of transitions for each state (and sets state numbers).

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

Returns a clone of this automaton, expands if singleton.

Search the input in linear time based on the size of the input to identify whether this automaton is contained anywhere in the input. <p>Has the foll

Returns a clone of this automaton, or this automaton itself if <code>allow_mutation</code> flag is set.

Expands singleton representation to normal representation. Does nothing if not in singleton representation.

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

Gets initial state. @return state

Resets transition set.

Assigns consecutive numbers to the given states.

Performs lookup in transitions, assuming determinism. @param c character to look up @return destination state, null if no matching outgoing transition

Returns the set of outgoing transitions. Subsequent changes are reflected in the automaton. @return transition set

Sets acceptance for this state. @param accept if true, this state is an accept state

Returns an automaton that accepts the concatenation of the languages of the given automata. <p> Complexity: linear in number of states.

Determinizes the given automaton. <p> Complexity: exponential in number of states.

Return <code>true</code> if this state has any children (outgoing transitions).

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

Reduces this automaton. An automaton is "reduced" by combining overlapping and adjacent edge intervals with same destination.

Returns true if the given string is accepted by the automaton. <p> Complexity: linear in the length of the string. <p> <b>Note:</b> for full performan

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

Returns a new (deterministic) automaton that accepts a single character of the given value.

Returns a new (deterministic) automaton that accepts only the empty string.

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

Returns a new (deterministic) automaton that accepts the single given string.

Reverses the language of the given (non-singleton) automaton while returning the set of new initial states.

Returns true if the given string is accepted by this automaton.

Sets or resets allow mutate flag. If this flag is set, then all automata operations may modify automata given as input; otherwise, operations will alw

Returns an automaton where all transition labels have been substituted. <p> Each transition labeled <code>c</code> is changed to a set of transitions,

See {@link BasicOperations#addEpsilons(Automaton, Collection)}.

Constructs sub-automaton corresponding to decimal numbers of length x.substring(n).length().

Finds the largest entry whose value is less than or equal to c, or 0 if there is no such entry.

Returns the number of transitions in this automaton. This number is counted as the total number of edges, where one edge may be a character interval.

Returns a shortest accepted/rejected string. If more than one shortest string is found, the lexicographically first of the shortest strings is returne

Returns transitions sorted by (min, reverse max, to) or (to, min, reverse max)

Returns sorted array of all interval start points.

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

Returns acceptance status. @return true is this is an accept state

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

Returns a new (deterministic) automaton that accepts a single char whose value is in the given interval (including both end points).

Helper method to check that the last match attempt was valid.

Helper method that requires the group argument to be 0.

Returns an automaton that accepts the Kleene star (zero or more concatenated repetitions) of the language of the given automaton. Never modifies the i

Returns the state obtained by reading the given char from the given state. Returns -1 if not obtaining any such state. (If the original <code>Automato

Constructs string from parsed regular expression.

Adds transitions to explicit crash state to ensure that transition function is total.

Returns an automaton that accepts the union of the languages of the given automata. <p> Complexity: linear in number of states.

Compares this object with the specified object for order. States are ordered by the time of construction.

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

Returns a (deterministic) automaton that accepts the complement of the language of the given automaton. <p> Complexity: linear in number of states (if