RedactableString is a string that contains a mix of safe and unsafe bits of data, but where it is known that unsafe bits are enclosed by redaction mar

HashString represents a string that should be hashed when redacted.

RedactableBytes is like RedactableString but is a byte slice. Instances of RedactableBytes should not be constructed directly; instead use the facili

SafeString represents a string that is not a sensitive value.

HashInt represents an integer that should be hashed when redacted.

HashFloat represents a floating-point value that should be hashed when redacted.

SafeFloat represents a floating-point value that is not a sensitive value.

SafeInt represents an integer that is not a sensitive value.

SafeRune aliases rune. See the explanation for SafeString.

SafeUint represents an integer that is not a sensitive value.

HashByte represents a byte that should be hashed when redacted.

HashBytes represents a byte slice that should be hashed when redacted.

HashRune represents a rune that should be hashed when redacted.

HashUint represents an unsigned integer that should be hashed when redacted.

sortableSlice attaches the methods of sort.Interface to []RedactableString, sorting in increasing order.

Buffer is a variable-sized buffer of bytes with a Write method. Writes are escaped in different ways depending on the output mode.

Formatter is implemented by any value that has a Format method. The implementation controls how State and rune are interpreted, and may call Sprint(f)

GoStringer is implemented by any value that has a GoString method, which defines the Go syntax for that value. The GoString method is used to print va

HashValue is a marker interface to be implemented by types whose values should be hashed when redacted, instead of being replaced with the redaction m

OutputMode determines how writes are processed in the Buffer.

SafeByte represents a byte that is not a sensitive value.

SafeBytes represents a byte slice that is not a sensitive value.

SafeFormatter is implemented by object types that want to separate safe and non-safe information when printed out by a Printf-like formatter.

SafePrinter is a stateful helper that abstracts an output stream in the context of printf-like formatting, but with the ability to separate safe and u

SafeValue is a marker interface to be implemented by types that alias base Go types and whose natural representation via Printf is always safe for rep

SafeWriter provides helper functions for use in implementations of SafeFormatter, to format mixes of safe and unsafe strings.

Note: Throughout this package we avoid calling reflect.Value.Interface as it is not always legal to do so and it's easier to avoid the issue than to f

State represents the printer state passed to custom formatters. It provides access to the io.Writer interface plus information about the flags and opt

StringBuilder accumulates strings with optional redaction markers. It implements io.Writer but marks direct writes as redactable. To distinguish safe

Stringer is implemented by any value that has a String method, which defines the `native` format for that value. The String method is used to print va

CUSTOM: smarter buffer.

A fmt is the raw formatter used by Printf etc. It prints into a buffer that must be set up separately.

flags placed in a separate struct for easy clearing.

hasherState holds a reusable hash.Hash and a pre-allocated Sum buffer. sumBuf must live in the pool because Sum() is an interface method — the compile

pp is used to store a printer's state and is reused with sync.Pool to avoid allocations.

Also a struct containing the safe type.