automaton

type Automaton ¶

type Automaton struct {
	// contains filtered or unexported fields
}

Represents an automaton and all its states and transitions. States are integers and must be created using {@link #createState}. Mark a state as an accept state using {@link #setAccept}. Add transitions using {@link #addTransition}. Each state must have all of its transitions added at once; if this is too restrictive then use {@link Automaton.Builder} instead. State 0 is always the initial state. Once a state is finished, either because you've starting adding transitions to another state or you call {@link #finishState}, then that states transitions are sorted (first by min, then max, then dest) and reduced (transitions with adjacent labels going to the same dest are combined).

func MakeEmpty() *Automaton

func (a *Automaton) IsAccept(state int) bool

func (a *Automaton) String() string

type AutomatonBuilder ¶

type AutomatonBuilder struct {
	// contains filtered or unexported fields
}

type AutomatonProvider ¶

type AutomatonProvider func(name string) *Automaton

Automaton provider for RegExp.

type CharacterRunAutomaton ¶

type CharacterRunAutomaton struct {
	*RunAutomaton
}

Automaton representation for matching []char

func NewCharacterRunAutomaton(a *Automaton) *CharacterRunAutomaton

type DaciukMihovAutomatonBuilder ¶

type DaciukMihovAutomatonBuilder struct {
}

type FrozenIntSet ¶

type FrozenIntSet struct {
	// contains filtered or unexported fields
}

func (fis *FrozenIntSet) String() string

type IntPair ¶

type IntPair struct {
	// contains filtered or unexported fields
}

type Kind ¶

type Kind int

type PointTransitionSet ¶

type PointTransitionSet struct {
	// contains filtered or unexported fields
}

func (pts *PointTransitionSet) String() string

type PointTransitions ¶

type PointTransitions struct {
	// contains filtered or unexported fields
}

Holds all transitions that start on this int point, or end at this point-1

type PointTransitionsArray ¶

type PointTransitionsArray []*PointTransitions

func (a PointTransitionsArray) Len() int

func (a PointTransitionsArray) Less(i, j int) bool

func (a PointTransitionsArray) Swap(i, j int)

type RegExp ¶

type RegExp struct {
	// contains filtered or unexported fields
}

Regular Expression extension to Automaton.

Regular expressions are built from the following abstract syntax:

	regexp	::= unionexp
 			|
	unionexp ::= interexp | unionexp 	(union)
	 		| interexp
	interexp ::= concatexp & interexp 	(intersection) 						[OPTIONAL]
 			| concatexp
	concatexp ::= repeatexp concatexp	 (concatenation)
 			| repeatexp
	repeatexp ::= repeatexp ? 			(zero or one occurrence)
 			| repeatexp * 				(zero or more occurrences)
 			| repeatexp + 				(one or more occurrences)
 			| repeatexp {n} 			(n occurrences)
 			| repeatexp {n,} 			(n or more occurrences)
 			| repeatexp {n,m} 			(n to m occurrences, including both)
 			| complexp
	complexp ::= ~ complexp 			(complement) 						[OPTIONAL]
 			| charclassexp
	charclassexp ::= [ charclasses ] 	(character class)
 			| [^ charclasses ] 			(negated character class)
 			| simpleexp
	charclasses ::= charclass charclasses
 			| charclass
	charclass ::= charexp - charexp 	(character range, including end-points)
 			| charexp
	simpleexp ::= charexp
 			| . 						(any single character)
 			| # 						(the empty language) 				[OPTIONAL]
 			| @ 						(any string) 						[OPTIONAL]
			| " <Unicode string without double-quotes>  " (a string)
 			| ( ) 						(the empty string)
 			| ( unionexp ) 				(precedence override)
 			| < <identifier> > 			(named automaton) 					[OPTIONAL]
			| <n-m> 					(numerical interval) 				[OPTIONAL]
	charexp ::= <Unicode character> 	(a single non-reserved character)
 			| \ <Unicode character>  	(a single character)

The productions marked [OPTIONAL] are only allowed if specified by the syntax flags passed to the RegExp constructor. The reserved characters used in the (enabled) syntax must be escaped with backslash (\) or double-quotes ("..."). (In contrast to other regexp syntaxes, this is required also in character classes.) Be aware that dash (-) has a special meaning in charclass expressions. An identifier is a string not containing right angle bracket (>) or dash (-). Numerical intervals are specified by non-negative decimal integers and include both end points, and if n and m have the same number of digits, then the conforming strings must have that length (i.e. prefixed by 0's).

func NewRegExp(s string) *RegExp

func NewRegExpWithFlag(s string, flags int) *RegExp

func (re *RegExp) String() string

func (re *RegExp) ToAutomaton() *Automaton

type RunAutomaton ¶

type RunAutomaton struct {
	// contains filtered or unexported fields
}

Finite-state automaton with fast run operation.

func (ra *RunAutomaton) String() string

type SortedIntSet ¶

type SortedIntSet struct {
	// contains filtered or unexported fields
}

Just holds a set of []int states, plus a corresponding []int count per state. Used by determinize().

I have to disable hashCode and use string key to mimic Lucene's custom hashing function here.

func (sis *SortedIntSet) String() string

type StateList ¶

type StateList struct {
	// contains filtered or unexported fields
}

type StateListNode ¶

type StateListNode struct {
	// contains filtered or unexported fields
}

type StatePair ¶

type StatePair struct {
	// contains filtered or unexported fields
}

Pair of states.

type Transition ¶

type Transition struct {
	// contains filtered or unexported fields
}

Holds one transition from an {@link Automaton}. This is typically used temporarily when iterating through transitions by invoking {@link Automaton#initTransition} and {@link Automaton#getNextTransition}.

func (t *Transition) String() string

type TransitionList ¶

type TransitionList struct {
	// contains filtered or unexported fields
}

Simple custom []*Transition