package xxhash

Import Path
	github.com/cespare/xxhash/v2 (on go.dev)

Dependency Relation
	imports 4 packages, and imported by one package

Involved Source Files

	  d xxhash.go
		Package xxhash implements the 64-bit variant of xxHash (XXH64) as described
		at http://cyan4973.github.io/xxHash/.

	    xxhash_asm.go
	    xxhash_unsafe.go
	    xxhash_amd64.s
Package-Level Type Names (total 2, in which 1 is exported)

	/* sort exporteds by: alphabet | popularity */
	 type Digest (struct)
		Digest implements hash.Hash64.
		
		Note that a zero-valued Digest is not ready to receive writes.
		Call Reset or create a Digest using New before calling other methods.

		Fields (total 7, none are exported)
			/* 7 unexporteds ... *//* 7 unexporteds: */
			mem [32]byte
			n int
				// how much of mem is used

			total uint64
			v1 uint64
			v2 uint64
			v3 uint64
			v4 uint64
		Methods (total 10, all are exported)
			(*Digest) BlockSize() int
				BlockSize always returns 32 bytes.

			(*Digest) MarshalBinary() ([]byte, error)
				MarshalBinary implements the encoding.BinaryMarshaler interface.

			(*Digest) Reset()
				Reset clears the Digest's state so that it can be reused.
				It uses a seed value of zero.

			(*Digest) ResetWithSeed(seed uint64)
				ResetWithSeed clears the Digest's state so that it can be reused.
				It uses the given seed to initialize the state.

			(*Digest) Size() int
				Size always returns 8 bytes.

			(*Digest) Sum(b []byte) []byte
				Sum appends the current hash to b and returns the resulting slice.

			(*Digest) Sum64() uint64
				Sum64 returns the current hash.

			(*Digest) UnmarshalBinary(b []byte) error
				UnmarshalBinary implements the encoding.BinaryUnmarshaler interface.

			(*Digest) Write(b []byte) (n int, err error)
				Write adds more data to d. It always returns len(b), nil.

			(*Digest) WriteString(s string) (n int, err error)
				WriteString adds more data to d. It always returns len(s), nil.
				It may be faster than Write([]byte(s)) by avoiding a copy.

		Implements (at least 11, in which 7 are exported)
			*Digest : encoding.BinaryMarshaler
			*Digest : encoding.BinaryUnmarshaler
			*Digest : hash.Hash
			*Digest : hash.Hash64
			*Digest : internal/bisect.Writer
			*Digest : io.StringWriter
			*Digest : io.Writer
			/* 4+ unexporteds ... *//* 4+ unexporteds: */
			*Digest : github.com/refraction-networking/utls.transcriptHash
			*Digest : crypto/internal/fips140/hmac.marshalable
			*Digest : crypto/tls.transcriptHash
			*Digest : net/http.http2stringWriter
		As Outputs Of (at least 2, both are exported)
			func New() *Digest
			func NewWithSeed(seed uint64) *Digest
		As Inputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func writeBlocks(d *Digest, b []byte) int

	/* one unexported ... *//* one unexported: */
	 type sliceHeader (struct)
		sliceHeader is similar to reflect.SliceHeader, but it assumes that the layout
		of the first two words is the same as the layout of a string.

		Fields (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			cap int
			s string


Package-Level Functions (total 19, in which 4 are exported)

	 func New() *Digest
		New creates a new Digest with a zero seed.

	 func NewWithSeed(seed uint64) *Digest
		NewWithSeed creates a new Digest with the given seed.

	 func Sum64(b []byte) uint64
		Sum64 computes the 64-bit xxHash digest of b with a zero seed.

	 func Sum64String(s string) uint64
		Sum64String computes the 64-bit xxHash digest of s with a zero seed.
		It may be faster than Sum64([]byte(s)) by avoiding a copy.

	/* 15 unexporteds ... *//* 15 unexporteds: */
	 func appendUint64(b []byte, x uint64) []byte
	 func consumeUint64(b []byte) ([]byte, uint64)
	 func mergeRound(acc, val uint64) uint64
	 func rol1(x uint64) uint64
	 func rol11(x uint64) uint64
	 func rol12(x uint64) uint64
	 func rol18(x uint64) uint64
	 func rol23(x uint64) uint64
	 func rol27(x uint64) uint64
	 func rol31(x uint64) uint64
	 func rol7(x uint64) uint64
	 func round(acc, input uint64) uint64
	 func u32(b []byte) uint32
	 func u64(b []byte) uint64
	 func writeBlocks(d *Digest, b []byte) int
Package-Level Variables (only one, which is unexported)

	/* one unexported ... *//* one unexported: */
	  var primes [5]uint64
		Store the primes in an array as well.
		
		The consts are used when possible in Go code to avoid MOVs but we need a
		contiguous array for the assembly code.


Package-Level Constants (total 7, none are exported)

	/* 7 unexporteds ... *//* 7 unexporteds: */
	const magic = "xxh\x06"
	const marshaledSize int = 76
	const prime1 uint64 = 11400714785074694791
	const prime2 uint64 = 14029467366897019727
	const prime3 uint64 = 1609587929392839161
	const prime4 uint64 = 9650029242287828579
	const prime5 uint64 = 2870177450012600261

The pages are generated with Golds v0.8.4. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds.