...

#
Package suffixarray

Package suffixarray implements substring search in logarithmic time using
an in-memory suffix array.

Example use:

// create index for some data
index := suffixarray.New(data)
// lookup byte slice s
offsets1 := index.Lookup(s, -1) // the list of all indices where s occurs in data
offsets2 := index.Lookup(s, 3) // the list of at most 3 indices where s occurs in data

In the call graph viewer below, each node
is a function belonging to this package
and its children are the functions it
calls—perhaps dynamically.

The root nodes are the entry points of the
package: functions that may be called from
outside the package.
There may be non-exported or anonymous
functions among them if they are called
dynamically from another package.

Click a node to visit that function's source code.
From there you can visit its callers by
clicking its declaring `func`

token.

Functions may be omitted if they were
determined to be unreachable in the
particular programs or tests that were
analyzed.

Index implements a suffix array for fast substring search.

type Index struct {
}

func New(data []byte) *Index

New creates a new Index for data.
Index creation time is O(N*log(N)) for N = len(data).

### func (*Index) Bytes
¶

func (x *Index) Bytes() []byte

Bytes returns the data over which the index was created.
It must not be modified.

func (x *Index) FindAllIndex(r *regexp.Regexp, n int) (result [][]int)

FindAllIndex returns a sorted list of non-overlapping matches of the
regular expression r, where a match is a pair of indices specifying
the matched slice of x.Bytes(). If n < 0, all matches are returned
in successive order. Otherwise, at most n matches are returned and
they may not be successive. The result is nil if there are no matches,
or if n == 0.

### func (*Index) Lookup
¶

func (x *Index) Lookup(s []byte, n int) (result []int)

Lookup returns an unsorted list of at most n indices where the byte string s
occurs in the indexed data. If n < 0, all occurrences are returned.
The result is nil if s is empty, s is not found, or n == 0.
Lookup time is O(log(N)*len(s) + len(result)) where N is the
size of the indexed data.

### func (*Index) Read
¶

func (x *Index) Read(r io.Reader) error

Read reads the index from r into x; x must not be nil.

### func (*Index) Write
¶

func (x *Index) Write(w io.Writer) error

Write writes the index x to w.