std/encoding/base32

Index

Variables
fn NewEncoder(mut enc: &Encoding, mut w: io::Writer): io::WriteCloser
fn NewDecoder(mut enc: &Encoding, mut r: io::Reader): io::Reader
type CorruptInputError
    fn Str(*self): str
struct Encoding
    fn New(table: str, padding: byte): &Encoding
    fn EncodedLen(*self, n: int): int
    fn DecodedLen(*self, n: int): int
    fn Encode(*self, mut dst: []byte, src: []byte)
    fn AppendEncode(*self, mut dst: []byte, src: []byte): []byte
    fn EncodeToStr(*self, src: []byte): str
    fn Decode(*self, mut dst: []byte, src: []byte)!: (n: int)
    fn AppendDecode(*self, mut dst: []byte, src: []byte)!: []byte
    fn DecodeStr(*self, s: str)!: []byte

Variables

let mut StdEncoding = Encoding.New("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567", StdPadding)

The standard base32 encoding, as defined in RFC 4648.

---

let mut HexEncoding = Encoding.New("0123456789ABCDEFGHIJKLMNOPQRSTUV", StdPadding)

The “Extended Hex Alphabet” defined in RFC 4648. It is typically used in DNS.

---

const (
	StdPadding: byte = '=' // Standard padding character.
	NoPadding:  byte = 0   // No padding.
)

NewEncoder

fn NewEncoder(mut enc: &Encoding, mut w: io::Writer): io::WriteCloser

Returns a new base32 stream encoder. Data written to the returned writer will be encoded using enc and then written to w. Base32 encodings operate in 5-byte blocks; when finished writing, the caller must Close the returned encoder to flush any partially written blocks.

NewDecoder

fn NewDecoder(mut enc: &Encoding, mut r: io::Reader): io::Reader

Constructs a new base32 stream decoder.

CorruptInputError

type CorruptInputError: i64

Str

fn Str(*self): str

Encoding

struct Encoding {
	// NOTE: contains filtered hidden or unexported fields
}

A radix 32 encoding/decoding scheme, defined by a 32-character alphabet. The most common is the "base32" encoding introduced for SASL GSSAPI and standardized in RFC 4648. The alternate "base32hex" encoding is used in DNSSEC.

New

fn New(table: str, padding: byte): &Encoding

Returns a new padded Encoding defined by the given alphabet, which must be a 32-byte string that contains unique byte values and does not contain the padding character or CR / LF ('\r', '\n'). The alphabet is treated as a sequence of byte values without any special treatment for multi-byte UTF-8.

EncodedLen

fn EncodedLen(*self, n: int): int

Returns the length in bytes of the base32 encoding of an input buffer of length n.

DecodedLen

fn DecodedLen(*self, n: int): int

Returns the maximum length in bytes of the decoded data corresponding to n bytes of base32-encoded data.

Encode

fn Encode(*self, mut dst: []byte, src: []byte)

Encodes src using the encoding, writing [Encoding.EncodedLen](len(src)) bytes to dst.

The encoding pads the output to a multiple of 8 bytes, so Encode is not appropriate for use on individual blocks of a large data stream. Use [NewEncoder] instead.

It panics if len(dst) is not enough for encoded length.

AppendEncode

fn AppendEncode(*self, mut dst: []byte, src: []byte): []byte

Appends the base32 encoded src to dst and returns the extended buffer.

EncodeToStr

fn EncodeToStr(*self, src: []byte): str

Returns the base32 encoding of src.

Decode

fn Decode(*self, mut dst: []byte, src: []byte)!: (n: int)

Decodes src using the encoding. It writes at most [Encoding.DecodedLen](len(src)) bytes to dst and returns the number of bytes written. The caller must ensure that dst is large enough to hold all the decoded data.

It panics if len(dst) is not enough for decoded length.

AppendDecode

fn AppendDecode(*self, mut dst: []byte, src: []byte)!: []byte

Appends the base32 decoded src to dst and returns the extended buffer. If the input is malformed, it returns the partially decoded src and an error.

DecodeStr

fn DecodeStr(*self, s: str)!: []byte

Returns the bytes represented by the base32 string s. If the input is malformed, it returns the partially decoded data.