Example_build shows how to build a simple trie. It assigns the value 1 to 100 random runes generated by randomRunes.

Code:play 

package main

import (
	"fmt"
	"io"
	"math/rand"
	"unicode"

	"golang.org/x/text/internal/triegen"
)

const seed = 0x12345

var genWriter = io.Discard

func randomRunes() map[rune]uint8 {
	rnd := rand.New(rand.NewSource(seed))
	m := map[rune]uint8{}
	for len(m) < 100 {

		if r := rune(rnd.Int31n(unicode.MaxRune + 1)); []rune(string(r))[0] == r {
			m[r] = 1
		}
	}
	return m
}

func main() {
	t := triegen.NewTrie("rand")

	for r, _ := range randomRunes() {
		t.Insert(r, 1)
	}
	sz, err := t.Gen(genWriter)

	fmt.Printf("Trie size: %d bytes\n", sz)
	fmt.Printf("Error:     %v\n", err)

}

Output:

Trie size: 9280 bytes
Error:     <nil>

Example_lookup demonstrates how to use the trie generated by Example_build.

Code:

{
	trie := newRandTrie(0)

	// The same set of runes used by Example_build.
	runes := randomRunes()

	// Verify the right value is returned for all runes.
	for r := rune(0); r <= unicode.MaxRune; r++ {
		// Note that the return type of lookup is uint8.
		if v, _ := trie.lookupString(string(r)); v != runes[r] {
			fmt.Println("FAILURE")
			return
		}
	}
	fmt.Println("SUCCESS")

	// Output:
	// SUCCESS
}

Output:

SUCCESS

ExampleGen_build demonstrates the creation of multiple tries sharing common blocks. ExampleGen_lookup demonstrates how to use the generated tries.

Code:play 

package main

import (
	"fmt"
	"io"
	"math/rand"
	"unicode"

	"golang.org/x/text/internal/triegen"
)

const seed = 0x12345

var genWriter = io.Discard

// runeValues generates some random values for a set of interesting runes.
func runeValues() map[rune]uint64 {
	rnd := rand.New(rand.NewSource(seed))
	m := map[rune]uint64{}
	for p := 4; p <= unicode.MaxRune; p <<= 1 {
		for d := -1; d <= 1; d++ {
			m[rune(p+d)] = uint64(rnd.Int63())
		}
	}
	return m
}

func main() {
	var tries []*triegen.Trie

	rv := runeValues()
	for _, c := range []struct {
		include func(rune) bool
		name    string
	}{
		{func(r rune) bool { return true }, "all"},
		{func(r rune) bool { return r < 0x80 }, "ASCII only"},
		{func(r rune) bool { return r < 0x80 }, "ASCII only 2"},
		{func(r rune) bool { return r <= 0xFFFF }, "BMP only"},
		{func(r rune) bool { return r > 0xFFFF }, "No BMP"},
	} {
		t := triegen.NewTrie(c.name)
		tries = append(tries, t)

		for r, v := range rv {
			if c.include(r) {
				t.Insert(r, v)
			}
		}
	}
	sz, err := triegen.Gen(genWriter, "multi", tries)

	fmt.Printf("Trie size: %d bytes\n", sz)
	fmt.Printf("Error:     %v\n", err)

}

Output:

Trie size: 18250 bytes
Error:     <nil>

ExampleGen_lookup shows how to look up values in the trie generated by ExampleGen_build.

Code:

{
	rv := runeValues()
	for i, include := range []func(rune) bool{
		func(r rune) bool { return true },        // all
		func(r rune) bool { return r < 0x80 },    // ASCII only
		func(r rune) bool { return r < 0x80 },    // ASCII only 2
		func(r rune) bool { return r <= 0xFFFF }, // BMP only
		func(r rune) bool { return r > 0xFFFF },  // No BMP
	} {
		t := newMultiTrie(i)

		for r := rune(0); r <= unicode.MaxRune; r++ {
			x := uint64(0)
			if include(r) {
				x = rv[r]
			}
			// As we convert from a valid rune, we know it is safe to use
			// lookupStringUnsafe.
			if v := t.lookupStringUnsafe(string(r)); x != v {
				fmt.Println("FAILURE")
				return
			}
		}
	}
	fmt.Println("SUCCESS")

	// Output:
	// SUCCESS
}

Output:

SUCCESS

Code:play 

package main

import (
	"fmt"
	"io"

	"golang.org/x/text/internal/triegen"
)

func main() {
	t := triegen.NewTrie("root")
	for r := rune(0); r < 10000; r += 64 {
		t.Insert(r, 0x9015BADA55^uint64(r))
	}
	sz, _ := t.Gen(io.Discard)

	fmt.Printf("Size normal:    %5d\n", sz)

	var c myCompacter
	sz, _ = t.Gen(io.Discard, triegen.Compact(&c))

	fmt.Printf("Size compacted: %5d\n", sz)

}

// A myCompacter accepts a block if only the first value is given.
type myCompacter []uint64

func (c *myCompacter) Size(values []uint64) (sz int, ok bool) {
	for _, v := range values[1:] {
		if v != 0 {
			return 0, false
		}
	}
	return 8, true // the size of a uint64
}

func (c *myCompacter) Store(v []uint64) uint32 {
	x := uint32(len(*c))
	*c = append(*c, v[0])
	return x
}

func (c *myCompacter) Print(w io.Writer) error {
	fmt.Fprintln(w, "var firstValue = []uint64{")
	for _, v := range *c {
		fmt.Fprintf(w, "\t%#x,\n", v)
	}
	fmt.Fprintln(w, "}")
	return nil
}

func (c *myCompacter) Handler() string {
	return "getFirstValue"

	// Where getFirstValue is included along with the generated code:
	// func getFirstValue(n uint32, b byte) uint64 {
	//     if b == 0x80 { // the first continuation byte
	//         return firstValue[n]
	//     }
	//     return 0
	//  }
}

Output:

Size normal:    81344
Size compacted:  3224