Documentation
¶
Overview ¶
Package hex implements hexadecimal encoding and decoding. Based on the encoding/hex package.
Index ¶
- Variables
- func AppendDecode(a mem.Allocator, dst, src []byte) ([]byte, error)
- func AppendEncode(a mem.Allocator, dst, src []byte) []byte
- func Decode(dst, src []byte) (int, error)
- func DecodeString(a mem.Allocator, s string) ([]byte, error)
- func DecodedLen(x int) int
- func Dump(a mem.Allocator, data []byte) string
- func Encode(dst, src []byte) int
- func EncodeToString(a mem.Allocator, src []byte) string
- func EncodedLen(n int) int
- type Decoder
- type Dumper
- type Encoder
Examples ¶
Constants ¶
This section is empty.
Variables ¶
var ErrDumperClosed = errors.New("encoding/hex: dumper closed")
ErrDumperClosed reports an attempt to write to a closed dumper.
var ErrInvalidByte = errors.New("encoding/hex: invalid byte")
ErrInvalidByte reports an invalid byte in the input.
var ErrLength = errors.New("encoding/hex: odd length hex string")
ErrLength reports an attempt to decode an odd-length input using Decode or DecodeString. The stream-based Decoder returns io.ErrUnexpectedEOF instead of ErrLength.
Functions ¶
func AppendDecode ¶
AppendDecode appends the hexadecimally decoded src to dst and returns the extended buffer. If the input is malformed, it returns the partially decoded src and an error.
func AppendEncode ¶
AppendEncode appends the hexadecimally encoded src to dst and returns the extended buffer.
func Decode ¶
Decode decodes src into DecodedLen(len(src)) bytes, returning the actual number of bytes written to dst.
Decode expects that src contains only hexadecimal characters and that src has even length. If the input is malformed, Decode returns the number of bytes decoded before the error.
Example ¶
package main
import (
"solod.dev/so/encoding/hex"
"solod.dev/so/fmt"
)
func main() {
src := []byte("48656c6c6f20476f7068657221")
dst := make([]byte, hex.DecodedLen(len(src)))
n, err := hex.Decode(dst, src)
if err != nil {
panic(err)
}
fmt.Printf("%s\n", dst[:n])
}
Output: Hello Gopher!
func DecodeString ¶
DecodeString returns the bytes represented by the hexadecimal string s.
DecodeString expects that src contains only hexadecimal characters and that src has even length. If the input is malformed, DecodeString returns the bytes decoded before the error.
The returned slice is allocated; the caller owns it.
Example ¶
package main
import (
"solod.dev/so/encoding/hex"
"solod.dev/so/fmt"
"solod.dev/so/mem"
)
func main() {
const s = "48656c6c6f20476f7068657221"
decoded, err := hex.DecodeString(mem.System, s)
if err != nil {
panic(err)
}
defer mem.FreeSlice(mem.System, decoded)
fmt.Printf("%s\n", decoded)
}
Output: Hello Gopher!
func DecodedLen ¶
DecodedLen returns the length of a decoding of x source bytes. Specifically, it returns x / 2.
func Dump ¶
Dump returns a string that contains a hex dump of the given data. The format of the hex dump matches the output of `hexdump -C` on the command line. The returned string is allocated; the caller owns it.
Example ¶
package main
import (
"solod.dev/so/encoding/hex"
"solod.dev/so/fmt"
"solod.dev/so/mem"
)
func main() {
content := []byte("Go is an open source programming language.")
dmp := hex.Dump(mem.System, content)
defer mem.FreeString(mem.System, dmp)
fmt.Printf("%s", dmp)
}
Output: 00000000 47 6f 20 69 73 20 61 6e 20 6f 70 65 6e 20 73 6f |Go is an open so| 00000010 75 72 63 65 20 70 72 6f 67 72 61 6d 6d 69 6e 67 |urce programming| 00000020 20 6c 61 6e 67 75 61 67 65 2e | language.|
func Encode ¶
Encode encodes src into EncodedLen(len(src)) bytes of dst. As a convenience, it returns the number of bytes written to dst, but this value is always EncodedLen(len(src)). Encode implements hexadecimal encoding.
Example ¶
package main
import (
"solod.dev/so/encoding/hex"
"solod.dev/so/fmt"
)
func main() {
src := []byte("Hello Gopher!")
dst := make([]byte, hex.EncodedLen(len(src)))
hex.Encode(dst, src)
fmt.Printf("%s\n", dst)
}
Output: 48656c6c6f20476f7068657221
func EncodeToString ¶
EncodeToString returns the hexadecimal encoding of src. The returned string is allocated; the caller owns it.
Example ¶
package main
import (
"solod.dev/so/encoding/hex"
"solod.dev/so/fmt"
"solod.dev/so/mem"
)
func main() {
src := []byte("Hello")
encodedStr := hex.EncodeToString(mem.System, src)
defer mem.FreeString(mem.System, encodedStr)
fmt.Printf("%s\n", encodedStr)
}
Output: 48656c6c6f
func EncodedLen ¶
EncodedLen returns the length of an encoding of n source bytes. Specifically, it returns n * 2.
Types ¶
type Decoder ¶
type Decoder struct {
// contains filtered or unexported fields
}
Decoder implements an io.Reader that reads hexadecimal characters from an underlying io.Reader and decodes them.
func NewDecoder ¶
NewDecoder returns a new Decoder that reads from r. NewDecoder expects that r contain only an even number of hexadecimal characters.
type Dumper ¶
type Dumper struct {
// contains filtered or unexported fields
}
Example ¶
package main
import (
"os"
"solod.dev/so/encoding/hex"
)
func main() {
lines := []string{
"Go is an open source programming language.",
"\n",
"We encourage all Go users to subscribe to golang-announce.",
}
stdoutDumper := hex.NewDumper(os.Stdout)
defer stdoutDumper.Close()
for _, line := range lines {
stdoutDumper.Write([]byte(line))
}
}
Output: 00000000 47 6f 20 69 73 20 61 6e 20 6f 70 65 6e 20 73 6f |Go is an open so| 00000010 75 72 63 65 20 70 72 6f 67 72 61 6d 6d 69 6e 67 |urce programming| 00000020 20 6c 61 6e 67 75 61 67 65 2e 0a 57 65 20 65 6e | language..We en| 00000030 63 6f 75 72 61 67 65 20 61 6c 6c 20 47 6f 20 75 |courage all Go u| 00000040 73 65 72 73 20 74 6f 20 73 75 62 73 63 72 69 62 |sers to subscrib| 00000050 65 20 74 6f 20 67 6f 6c 61 6e 67 2d 61 6e 6e 6f |e to golang-anno| 00000060 75 6e 63 65 2e |unce.|
func NewDumper ¶
NewDumper returns a io.WriteCloser that writes a hex dump of all written data to w. The format of the dump matches the output of `hexdump -C` on the command line.
Source Files