rlp

Documentation

Index

• Variables
• func AppendUint64(b []byte, i uint64) []byte
• func CountValues(b []byte) (int, error)
• func Decode(r io.Reader, val interface{}) error
• func DecodeBytes(b []byte, val interface{}) error
• func Encode(w io.Writer, val interface{}) error
• func EncodeToBytes(val interface{}) ([]byte, error)
• func EncodeToReader(val interface{}) (size int, r io.Reader, err error)
• func IntSize(x uint64) int
• func SplitList(b []byte) (content, rest []byte, err error)
• func SplitString(b []byte) (content, rest []byte, err error)
• func SplitUint64(b []byte) (x uint64, rest []byte, err error)
• type ByteReader
• type Decoder
• type Encoder
• type EncoderBuffer
  • func NewEncoderBuffer(dst io.Writer) EncoderBuffer
  • func (w *EncoderBuffer) AppendToBytes(dst []byte) []byte
  • func (w *EncoderBuffer) Flush() error
  • func (w EncoderBuffer) List() int
  • func (w EncoderBuffer) ListEnd(index int)
  • func (w *EncoderBuffer) Reset(dst io.Writer)
  • func (w *EncoderBuffer) ToBytes() []byte
  • func (w EncoderBuffer) Write(b []byte) (int, error)
  • func (w EncoderBuffer) WriteBytes(b []byte)
• type Kind
  • func Split(b []byte) (k Kind, content, rest []byte, err error)
• type RawValue
• type Stream
  • func NewStream(r io.Reader, inputLimit uint64) *Stream
  • func (s *Stream) Bool() (bool, error)
  • func (s *Stream) Bytes() ([]byte, error)
  • func (s *Stream) Decode(val interface{}) error
  • func (s *Stream) Kind() (kind Kind, size uint64, err error)
  • func (s *Stream) List() (size uint64, err error)
  • func (s *Stream) ListEnd() error
  • func (s *Stream) Raw() ([]byte, error)
  • func (s *Stream) Reset(r io.Reader, inputLimit uint64)

Variables

var (
	ErrExpectedString   = errors.New("rlp: expected String or Byte")
	ErrExpectedList     = errors.New("rlp: expected List")
	ErrCanonInt         = errors.New("rlp: non-canonical integer format")
	ErrCanonSize        = errors.New("rlp: non-canonical size information")
	ErrElemTooLarge     = errors.New("rlp: element is larger than containing list")
	ErrValueTooLarge    = errors.New("rlp: value size exceeds available input length")
	ErrMoreThanOneValue = errors.New("rlp: input contains more than one value")
)

var (
	// 通用编码值。
	//这些在实现EncodeRLP时很有用。
	EmptyString = []byte{0x80}
	EmptyList   = []byte{0xC0}
)

var EOL = errors.New("rlp: end of list")

流式处理期间到达当前列表的末尾时，将返回EOL。

var ErrNegativeBigInt = errors.New("rlp: cannot encode negative big.Int")

Functions

func AppendUint64

func AppendUint64(b []byte, i uint64) []byte

AppendUint64将i的RLP编码追加到b，并返回结果切片。

func CountValues

func CountValues(b []byte) (int, error)

CountValues统计b中编码值的数量。

func Decode

func Decode(r io.Reader, val interface{}) error

Decode解析来自r的RLP编码数据，并将结果存储在val指向的值中。Val必须是非nil指针。如果r没有实现ByteReader，Decode将自己进行缓冲。 请注意，Decode并没有为所有读卡器设置输入限制，并且可能容易受到巨大值大小导致的恐慌的影响。如果需要输入限制，请使用NewStream（r，limit）。解码（val）

func DecodeBytes

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

DecodeBytes将RLP数据从b解析为val。输入必须只包含一个值，并且不包含尾随数据。

func Encode

func Encode(w io.Writer, val interface{}) error

Encode将val的RLP编码写入w。请注意，Encode在某些情况下可能会执行许多小的写入。考虑将w设为缓冲。 请参阅编码规则的包级文档。

func EncodeToBytes

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

EncodeToBytes返回val的RLP编码。

func EncodeToReader

func EncodeToReader(val interface{}) (size int, r io.Reader, err error)

编码器读取器返回一个读取器，从中可以读取val的RLP编码。 返回的大小是编码数据的总大小。有关编码规则，请参阅Encode的文档。

func IntSize

func IntSize(x uint64) int

IntSize返回整数x的编码大小。

func SplitList

func SplitList(b []byte) (content, rest []byte, err error)

SplitList将b拆分为列表的内容和列表后的任何剩余字节。

func SplitString

func SplitString(b []byte) (content, rest []byte, err error)

SplitString将b拆分为RLP字符串的内容以及该字符串后面的任何剩余字节。

func SplitUint64

func SplitUint64(b []byte) (x uint64, rest []byte, err error)

SplitUint64解码b开头的整数。它还返回“rest”中整数之后的剩余数据。

Types

type ByteReader

type ByteReader interface {
	io.Reader
	io.ByteReader
}

ByterReader必须由流的任何输入读取器实现。由bufio等实施。读取器和字节。读者

type Decoder

type Decoder interface {
	DecodeRLP(*Stream) error
}

内部ErrorsCoder由需要自定义RLP解码规则或需要解码到私有字段的类型实现。 DecodeRLP方法应该从给定流中读取一个值。不禁止少读或多读，但这可能会令人困惑。

type Encoder

type Encoder interface {
	// EncodeRLP应该将其接收器的RLP编码写入w。
	//如果实现是指针方法，则也可以调用nil指针。实现应该生成有效的RLP。
	//写入的数据目前尚未验证，但将来的版本可能会验证。
	//建议只写入一个值，但也允许写入多个值或根本不写入值。
	EncodeRLP(io.Writer) error
}

编码器由需要自定义编码规则或想要编码私有字段的类型实现。

type EncoderBuffer

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

EncoderBuffer是增量编码的缓冲区。 零值未准备好使用。要获得可用的缓冲区，请使用NewEncoderBuffer或调用Reset创建它。

func NewEncoderBuffer

func NewEncoderBuffer(dst io.Writer) EncoderBuffer

NewEncoderBuffer创建编码器缓冲区。

func (*EncoderBuffer) AppendToBytes

func (w *EncoderBuffer) AppendToBytes(dst []byte) []byte

AppendToBytes将编码字节追加到dst。

func (*EncoderBuffer) Flush

func (w *EncoderBuffer) Flush() error

Flush将编码的RLP数据写入输出写入器。这只能调用一次。如果要在刷新后重新使用缓冲区，必须调用Reset。

func (EncoderBuffer) List

func (w EncoderBuffer) List() int

列表启动列表。它返回一个内部索引。对内容进行编码后，使用此索引调用EndList以完成列表。

func (EncoderBuffer) ListEnd

func (w EncoderBuffer) ListEnd(index int)

ListEnd完成给定的列表。

func (*EncoderBuffer) Reset

func (w *EncoderBuffer) Reset(dst io.Writer)

重置将截断缓冲区并设置输出目标。

func (*EncoderBuffer) ToBytes

func (w *EncoderBuffer) ToBytes() []byte

ToBytes返回编码的字节。

func (EncoderBuffer) Write

func (w EncoderBuffer) Write(b []byte) (int, error)

写入将b直接附加到编码器输出。

func (EncoderBuffer) WriteBytes

func (w EncoderBuffer) WriteBytes(b []byte)

WriteBytes将b编码为RLP字符串。

type Kind

type Kind int8

种类表示RLP流中包含的值的种类。

const (
	Byte Kind = iota
	String
	List
)

func Split

func Split(b []byte) (k Kind, content, rest []byte, err error)

Split返回第一个RLP值的内容以及该值之后的任何字节，作为b的子片。

type RawValue

type RawValue []byte

RawValue表示编码的RLP值，可用于延迟RLP解码或预计算编码。注意，解码器不验证RawValues的内容是否是有效的RLP。

type Stream

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

流可用于对输入流进行逐段解码。如果输入非常大，或者类型的解码规则取决于输入结构，则这非常有用。流不保留内部缓冲区。解码一个值后，输入读取器将位于下一个值的类型信息之前。 当解码列表且输入位置达到列表的声明长度时，所有操作将返回错误EOL。必须使用ListEnd确认列表结束，才能继续读取封闭列表。 流对于并发使用不安全。

func NewStream

func NewStream(r io.Reader, inputLimit uint64) *Stream

NewStream创建一个从r读取的新解码流。如果r实现ByteReader接口，则流不会引入任何缓冲。对于非顶级值，Stream为不符合封闭列表的值返回ErrElemTooLarge。 流支持可选的输入限制。如果设置了限制，将对照剩余输入长度检查任何toplevel值的大小。 遇到超过剩余输入长度的值的流操作将返回ErrValueTooLarge。可以通过为inputLimit传递非零值来设置限制。 如果r是字节。读取器或字符串。读取器，除非提供明确的限制，否则输入限制设置为r的基础数据的长度。

func (*Stream) Bool

func (s *Stream) Bool() (bool, error)

Bool读取最多1字节的RLP字符串，并以布尔值形式返回其内容。如果输入不包含RLP字符串，则返回的错误将是ErrExpectedString。

func (*Stream) Bytes

func (s *Stream) Bytes() ([]byte, error)

字节读取RLP字符串并将其内容作为字节片返回。如果输入不包含RLP字符串，则返回的错误将是ErrExpectedString。

func (*Stream) Decode

func (s *Stream) Decode(val interface{}) error

Decode对一个值进行解码，并将结果存储在val所指的值中.

func (*Stream) Kind

func (s *Stream) Kind() (kind Kind, size uint64, err error)

Kind返回输入流中下一个值的种类和大小。返回的大小是组成该值的字节数。对于kind==Byte，大小为零，因为该值包含在type标记中。 第一次调用Kind将从输入读取器读取大小信息，并将其定位在值的实际字节的开头。对Kind的后续调用（直到值被解码）不会使输入读取器前进并返回缓存的信息。

func (*Stream) List

func (s *Stream) List() (size uint64, err error)

List开始解码RLP列表。如果输入不包含列表，则返回的错误将是ErrExpectedList。当到达列表末尾时，任何流操作都将返回EOL。

func (*Stream) ListEnd

func (s *Stream) ListEnd() error

ListEnd返回到封闭列表。输入读取器必须位于列表的末尾。

func (*Stream) Raw

func (s *Stream) Raw() ([]byte, error)

Raw读取包含RLP类型信息的原始编码值。

func (*Stream) Reset

func (s *Stream) Reset(r io.Reader, inputLimit uint64)

Reset丢弃有关当前解码上下文的任何信息，并开始从r读取。此方法旨在促进在许多解码操作中重用预分配流。 若r也并没有实现ByterReader，则流将自己进行缓冲。