rlp

func CountValues ¶

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

CountValues counts the number of encoded values in b. todo CountValues: 计算b中编码值的数量. todo 其实就是说， todo 其实就是说， todo 取出第一个字节 <前缀>

  如果有多个字段，则编码格式为:
 [list总前缀, 第一个元素前缀, 第一个元素[]byte, 第二个元素前缀, 第二个元素[]byte, ...]
所以入参应该为: 第一个元素前缀, 第一个元素[]byte, 第二个元素前缀, 第二个元素[]byte, ...]
才可以知道，得到的num是 几

func Decode ¶

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

Decode uses the following type-dependent decoding rules:

解码使用以下与类型有关的解码规则：

If the type implements the Decoder interface, decode calls DecodeRLP.

如果该类型实现了Decoder接口，则解码调用DecodeRLP。

To decode into a pointer, Decode will decode into the value pointed to. If the pointer is nil, a new value of the pointer's element type is allocated. If the pointer is non-nil, the existing value will be reused.

要解码为指针，解码将解码为指向的值。 如果指针为nil，则分配该指针的元素类型的新值。 如果指针为非零，则现有值将被重用。

To decode into a struct, Decode expects the input to be an RLP list. The decoded elements of the list are assigned to each public field in the order given by the struct's definition. The input list must contain an element for each decoded field. Decode returns an error if there are too few or too many elements.

为了解码成结构，Decode希望输入是RLP列表。 列表的解码元素按照结构定义给出的顺序分配给每个公共字段。 输入列表必须为每个解码字段包含一个元素。 如果元素太多或太多，解码将返回错误。

The decoding of struct fields honours certain struct tags, "tail", "nil" and "-".

结构字段的解码采用某些结构标签“ tail”，“ nil”和“-”。

The "-" tag ignores fields.

“-”标签忽略字段。

For an explanation of "tail", see the example.

有关“尾巴”的说明，请参见示例。

The "nil" tag applies to pointer-typed fields and changes the decoding rules for the field such that input values of size zero decode as a nil pointer. This tag can be useful when decoding recursive types.

“ nil”标签应用于指针类型的字段，并更改该字段的解码规则，以使大小为零的输入值解码为nil指针。 解码递归类型时，此标记很有用。

type StructWithEmptyOK struct {
    Foo *[20]byte `rlp:"nil"`
}

To decode into a slice, the input must be a list and the resulting slice will contain the input elements in order. For byte slices, the input must be an RLP string. Array types decode similarly, with the additional restriction that the number of input elements (or bytes) must match the array's length.

要解码为切片，输入必须是列表，并且所得切片将按顺序包含输入元素。 对于字节片，输入必须是RLP字符串。 数组类型的解码方式类似， 但附加的限制是输入元素（或字节）的数量必须与数组的长度匹配。

To decode into a Go string, the input must be an RLP string. The input bytes are taken as-is and will not necessarily be valid UTF-8.

要解码为 `Go字符串`，输入必须是RLP字符串。 输入字节按原样使用，不一定是有效的UTF-8。

To decode into an unsigned integer type, the input must also be an RLP string. The bytes are interpreted as a big endian representation of the integer. If the RLP string is larger than the bit size of the type, Decode will return an error. Decode also supports *big.Int. There is no size limit for big integers.

要解码为无符号整数类型，输入还必须是RLP字符串。 字节被解释为整数的 todo 【大端】表示。 如果RLP字符串大于该类型的位大小，则Decode将返回错误。 解码还支持* big.Int。 大整数没有大小限制。

To decode into an interface value, Decode stores one of these in the value:

要将解码为 `interface{}` 值，Decode将其中之一存储在值中：

[]interface{}, for RLP lists
[]byte, for RLP strings

Non-empty interface types are not supported, nor are booleans, signed integers, floating point numbers, maps, channels and functions.

todo 不支持非空 `interface{}`类型，也不支持 bool值<额， 看下面的代码 bool 其实是支持的>，带符号整数，float，map，chan和 func。

Note that Decode does not set an input limit for all readers and may be vulnerable to panics cause by huge value sizes. If you need an input limit, use

请注意，“解码” 并未为所有 `readers` 设置输入限制，并且可能因【值巨大】而引起恐慌。 如果需要输入限制，请使用

NewStream(r, limit).Decode(val)

input, _ := hex.DecodeString("C90A1486666F6F626172")

type example struct {
	A, B    uint
	private uint // private fields are ignored
	String  string
}

var s example
err := Decode(bytes.NewReader(input), &s)
if err != nil {
	fmt.Printf("Error: %v\n", err)
} else {
	fmt.Printf("Decoded value: %#v\n", s)
}

Output:

Decoded value: rlp.example{A:0xa, B:0x14, private:0x0, String:"foobar"}

// In this example, we'll use the "nil" struct tag to change
// how a pointer-typed field is decoded. The input contains an RLP
// list of one element, an empty string.
input := []byte{0xC1, 0x80}

// This type uses the normal rules.
// The empty input string is decoded as a pointer to an empty Go string.
var normalRules struct {
	String *string
}
Decode(bytes.NewReader(input), &normalRules)
fmt.Printf("normal: String = %q\n", *normalRules.String)

// This type uses the struct tag.
// The empty input string is decoded as a nil pointer.
var withEmptyOK struct {
	String *string `rlp:"nil"`
}
Decode(bytes.NewReader(input), &withEmptyOK)
fmt.Printf("with nil tag: String = %v\n", withEmptyOK.String)

Output:

normal: String = ""
with nil tag: String = <nil>

package main

import (
	"bytes"
	"fmt"
)

type structWithTail struct {
	A, B uint
	C    []uint `rlp:"tail"`
}

func main() {
	// In this example, the "tail" struct tag is used to decode lists of
	// differing length into a struct.
	var val structWithTail

	err := Decode(bytes.NewReader([]byte{0xC4, 0x01, 0x02, 0x03, 0x04}), &val)
	fmt.Printf("with 4 elements: err=%v val=%v\n", err, val)

	err = Decode(bytes.NewReader([]byte{0xC6, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06}), &val)
	fmt.Printf("with 6 elements: err=%v val=%v\n", err, val)

	// Note that at least two list elements must be present to
	// fill fields A and B:
	err = Decode(bytes.NewReader([]byte{0xC1, 0x01}), &val)
	fmt.Printf("with 1 element: err=%q\n", err)

}

Output:

with 4 elements: err=<nil> val={1 2 [3 4]}
with 6 elements: err=<nil> val={1 2 [3 4 5 6]}
with 1 element: err="rlp: too few elements for rlp.structWithTail"

func DecodeBytes ¶

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

DecodeBytes parses RLP data from b into val. Please see the documentation of Decode for the decoding rules. The input must contain exactly one value and no trailing data.

todo DecodeBytes:

将RLP数据从 `b` 解析到 `val`。 请参阅解码文档以获取解码规则。 输入必须仅包含一个值，并且不包含尾随数据。

func Encode ¶

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

Boolean values are not supported, nor are signed integers, floating point numbers, maps, channels and functions.

不支持布尔值，也不支持有符号整数、浮点数、映射、通道和函数。

func EncodeToBytes ¶

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

func EncodeToReader ¶

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

func ListSize ¶

func ListSize(contentSize uint64) uint64

ListSize returns the encoded size of an RLP list with the given content size.

func SplitList ¶

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

SplitList splits b into the content of a list and any remaining bytes after the list.

SplitList： 将b拆分为列表的内容和列表之后的所有剩余字节

todo 主要用来解 多字段编码的第一层list

			拆出   [list总前缀, 第一个元素前缀, 第一个元素[]byte, 第二个元素前缀, 第二个元素[]byte, ...]   中的
 		list前缀 并将 后面的内容 <就是第一前缀到 末尾> 作为第一个元素并返回， 第二个元素是个空<这里不管>

@return content: rlp中第一个元素内容 (不是首个代表长度的元素哦，是指首个代表内容的元素) rest: 剩余的元素 err: 错误信息

func SplitString ¶

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

SplitString splits b into the content of an RLP string and any remaining bytes after the string.

SplitString: 将b拆分为RLP字符串的内容以及该字符串之后的所有剩余字节

todo 主要用来解 多字段编码的第二层内容

用经过拆出 [list总前缀, 第一个元素前缀, 第一个元素[]byte, 第二个元素前缀, 第二个元素[]byte, ...] 中的
list前缀 之后的 后面的内容 作为 第一个元素并返回作为入参，返回里面第一个字段和后面的N个字段的rlp

@return content: rlp中第一个元素内容 (不是首个代表长度的元素哦，是指首个代表内容的元素) rest: 剩余的元素 err: 错误信息