Documentation
¶
Overview ¶
Package bencode implements encoding and decoding of bencoded objects, which has a similar API to the encoding/json package and many other serialization formats.
Notice: the package is ported from github.com/zeebo/bencode@v1.0.0
Index ¶
Examples ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
func DecodeBytes ¶
DecodeBytes reads the data in b and stores it into the value pointed to by val. Read the docs for Decode for more information.
Example ¶
var torrent interface{}
if err := DecodeBytes([]byte(data), &torrent); err != nil {
panic(err)
}
Output:
func DecodeString ¶
DecodeString reads the data in the string and stores it into the value pointed to by val. Read the docs for Decode for more information.
Example ¶
var torrent interface{}
if err := DecodeString(data, &torrent); err != nil {
panic(err)
}
Output:
func EncodeBytes ¶
EncodeBytes returns the bencoded data of val as a slice of bytes.
Example ¶
var torrent interface{}
data, err := EncodeBytes(torrent)
if err != nil {
panic(err)
}
fmt.Println(data)
Output:
func EncodeString ¶
EncodeString returns the bencoded data of val as a string.
Example ¶
var torrent interface{}
data, err := EncodeString(torrent)
if err != nil {
panic(err)
}
fmt.Println(data)
Output:
Types ¶
type Decoder ¶
type Decoder struct {
// contains filtered or unexported fields
}
A Decoder reads and decodes bencoded data from an input stream.
func NewDecoder ¶
NewDecoder returns a new decoder that reads from r
func (*Decoder) BytesParsed ¶
BytesParsed returns the number of bytes that have actually been parsed
func (*Decoder) Decode ¶
Decode reads the bencoded value from its input and stores it in the value pointed to by val. Decode allocates maps/slices as necessary with the following additional rules: To decode a bencoded value into a nil interface value, the type stored in the interface value is one of:
int64 for bencoded integers
string for bencoded strings
[]interface{} for bencoded lists
map[string]interface{} for bencoded dicts
To unmarshal bencode into a value implementing the Unmarshaler interface, Unmarshal calls that value's UnmarshalBencode method. Otherwise, if the value implements encoding.TextUnmarshaler and the input is a bencode string, Unmarshal calls that value's UnmarshalText method with the decoded form of the string.
Example ¶
dec := NewDecoder(r)
var torrent struct {
Announce string
List [][]string `bencode:"announce-list"`
}
if err := dec.Decode(&torrent); err != nil {
panic(err)
}
Output:
func (*Decoder) SetFailOnUnorderedKeys ¶
SetFailOnUnorderedKeys will cause the decoder to fail when encountering unordered keys. The default is to not fail.
type Encoder ¶
type Encoder struct {
// contains filtered or unexported fields
}
An Encoder writes bencoded objects to an output stream.
func NewEncoder ¶
NewEncoder returns a new encoder that writes to w.
func (*Encoder) Encode ¶
Encode writes the bencoded data of val to its output stream. If an encountered value implements the Marshaler interface, its MarshalBencode method is called to produce the bencode output for this value. If no MarshalBencode method is present but the value implements encoding.TextMarshaler instead, its MarshalText method is called, which encodes the result as a bencode string. See the documentation for Decode about the conversion of Go values to bencoded data.
Example ¶
var x struct {
Foo string
Bar []string `bencode:"name"`
}
enc := NewEncoder(w)
if err := enc.Encode(x); err != nil {
panic(err)
}
Output:
type Marshaler ¶
Marshaler is the interface implemented by types that can marshal themselves into valid bencode.
type RawMessage ¶
type RawMessage []byte
RawMessage is a special type that will store the raw bencode data when encoding or decoding.
type Unmarshaler ¶
Unmarshaler is the interface implemented by types that can unmarshal a bencode description of themselves. The input can be assumed to be a valid encoding of a bencode value. UnmarshalBencode must copy the bencode data if it wishes to retain the data after returning.
Source Files