bencode

package module
Version: v1.0.0 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Aug 19, 2018 License: MIT Imports: 12 Imported by: 151

README

bencode

GoDoc Build Status Sourcegraph

Bencode is a library for encoding/decoding bencoded data into Go data structures. The api is designed to be similar to the JSON api in the Go standard library.

Documentation

Documentation at http://godoc.org/github.com/zeebo/bencode

Documentation

Overview

Package bencode implements encoding and decoding of bencoded objects.

It has a similar API to the encoding/json package and many other serialization formats.

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

func DecodeBytes

func DecodeBytes(b []byte, val interface{}) error

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

func DecodeString(in string, val interface{}) error

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

func EncodeBytes(val interface{}) ([]byte, error)

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

func EncodeString(val interface{}) (string, error)

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

func NewDecoder(r io.Reader) *Decoder

NewDecoder returns a new decoder that reads from r

func (*Decoder) BytesParsed

func (d *Decoder) BytesParsed() int

BytesParsed returns the number of bytes that have actually been parsed

func (*Decoder) Decode

func (d *Decoder) Decode(val interface{}) error

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

func (d *Decoder) SetFailOnUnorderedKeys(fail bool)

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

func NewEncoder(w io.Writer) *Encoder

NewEncoder returns a new encoder that writes to w.

func (*Encoder) Encode

func (e *Encoder) Encode(val interface{}) error

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

type Marshaler interface {
	MarshalBencode() ([]byte, error)
}

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

type Unmarshaler interface {
	UnmarshalBencode([]byte) error
}

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.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL