bencode

README

Bencode encoding/decoding sub package. Uses similar API design to Go's json package.

Install

go get github.com/anacrolix/torrent

Usage

package demo

import (
	bencode "github.com/anacrolix/torrent/bencode"
)

type Message struct {
	Query    string `json:"q,omitempty" bencode:"q,omitempty"`
}

var v Message

func main(){
	// encode
	data, err := bencode.Marshal(v)
	if err != nil {
		log.Fatal(err)
	}
	
	//decode
	err := bencode.Unmarshal(data, &v)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(v)
}

Documentation

Index

• func Marshal(v interface{}) ([]byte, error)
• func MustMarshal(v interface{}) []byte
• func Unmarshal(data []byte, v interface{}) (err error)
• type Bytes
  • func (me Bytes) MarshalBencode() ([]byte, error)
  • func (me *Bytes) UnmarshalBencode(b []byte) error
• type Decoder
  • func NewDecoder(r io.Reader) *Decoder
  • func (d *Decoder) Decode(v interface{}) (err error)
• type Encoder
  • func NewEncoder(w io.Writer) *Encoder
  • func (e *Encoder) Encode(v interface{}) (err error)
• type ErrUnusedTrailingBytes
  • func (me ErrUnusedTrailingBytes) Error() string
• type MarshalTypeError
  • func (e *MarshalTypeError) Error() string
• type Marshaler
• type MarshalerError
  • func (e *MarshalerError) Error() string
• type SyntaxError
  • func (e *SyntaxError) Error() string
• type UnmarshalFieldError
  • func (e *UnmarshalFieldError) Error() string
• type UnmarshalInvalidArgError
  • func (e *UnmarshalInvalidArgError) Error() string
• type UnmarshalTypeError
  • func (e *UnmarshalTypeError) Error() string
• type Unmarshaler
• type UnmarshalerError
  • func (e *UnmarshalerError) Error() string

Functions

func Marshal

func Marshal(v interface{}) ([]byte, error)

Marshal the value 'v' to the bencode form, return the result as []byte and an error if any.

func MustMarshal

func MustMarshal(v interface{}) []byte

func Unmarshal

func Unmarshal(data []byte, v interface{}) (err error)

Unmarshal the bencode value in the 'data' to a value pointed by the 'v' pointer, return a non-nil error if any. If there are trailing bytes, this results in ErrUnusedTrailingBytes, but the value will be valid. It's probably more consistent to use Decoder.Decode if you want to rely on this behaviour (inspired by Rust's serde here).

Types

type Bytes

type Bytes []byte

func (Bytes) MarshalBencode

func (me Bytes) MarshalBencode() ([]byte, error)

func (*Bytes) UnmarshalBencode

func (me *Bytes) UnmarshalBencode(b []byte) error

type Decoder

type Decoder struct {

	// Sum of bytes used to Decode values.
	Offset int64
	// contains filtered or unexported fields
}

func NewDecoder

func NewDecoder(r io.Reader) *Decoder

func (*Decoder) Decode

func (d *Decoder) Decode(v interface{}) (err error)

type Encoder

type Encoder struct {
	// contains filtered or unexported fields
}

func NewEncoder

func NewEncoder(w io.Writer) *Encoder

func (*Encoder) Encode

func (e *Encoder) Encode(v interface{}) (err error)

type ErrUnusedTrailingBytes

type ErrUnusedTrailingBytes struct {
	NumUnusedBytes int
}

func (ErrUnusedTrailingBytes) Error

func (me ErrUnusedTrailingBytes) Error() string

type MarshalTypeError

type MarshalTypeError struct {
	Type reflect.Type
}

In case if marshaler cannot encode a type, it will return this error. Typical example of such type is float32/float64 which has no bencode representation.

func (*MarshalTypeError) Error

func (e *MarshalTypeError) Error() string

type Marshaler

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

Any type which implements this interface, will be marshaled using the specified method.

type MarshalerError

type MarshalerError struct {
	Type reflect.Type
	Err  error
}

A non-nil error was returned after calling MarshalBencode on a type which implements the Marshaler interface.

func (*MarshalerError) Error

func (e *MarshalerError) Error() string

type SyntaxError

type SyntaxError struct {
	Offset int64 // location of the error
	What   error // error description
}

Malformed bencode input, unmarshaler failed to parse it.

func (*SyntaxError) Error

func (e *SyntaxError) Error() string

type UnmarshalFieldError

type UnmarshalFieldError struct {
	Key   string
	Type  reflect.Type
	Field reflect.StructField
}

Unmarshaler tried to write to an unexported (therefore unwritable) field.

func (*UnmarshalFieldError) Error

func (e *UnmarshalFieldError) Error() string

type UnmarshalInvalidArgError

type UnmarshalInvalidArgError struct {
	Type reflect.Type
}

Unmarshal argument must be a non-nil value of some pointer type.

func (*UnmarshalInvalidArgError) Error

func (e *UnmarshalInvalidArgError) Error() string

type UnmarshalTypeError

type UnmarshalTypeError struct {
	Value string
	Type  reflect.Type
}

Unmarshaler spotted a value that was not appropriate for a given Go value.

func (*UnmarshalTypeError) Error

func (e *UnmarshalTypeError) Error() string

type Unmarshaler

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

Any type which implements this interface, will be unmarshaled using the specified method.

type UnmarshalerError

type UnmarshalerError struct {
	Type reflect.Type
	Err  error
}

A non-nil error was returned after calling UnmarshalBencode on a type which implements the Unmarshaler interface.

func (*UnmarshalerError) Error

func (e *UnmarshalerError) Error() string